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, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, 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 %d of '%s' has out of range value '%u'"),
2711                       operand + 1,
2712                       xtensa_opcode_name (xtensa_default_isa, opcode),
2713                       value);
2714       else
2715         as_bad_where ((char *) file, line,
2716                       _("operand %d of '%s' has invalid value '%u'"),
2717                       operand + 1,
2718                       xtensa_opcode_name (xtensa_default_isa, opcode),
2719                       value);
2720       return;
2721     }
2722
2723   xtensa_operand_set_field (xtensa_default_isa, opcode, operand, fmt, slot,
2724                             slotbuf, valbuf);
2725 }
2726
2727
2728 static uint32
2729 xtensa_insnbuf_get_operand (xtensa_insnbuf slotbuf,
2730                             xtensa_format fmt,
2731                             int slot,
2732                             xtensa_opcode opcode,
2733                             int opnum)
2734 {
2735   uint32 val = 0;
2736   (void) xtensa_operand_get_field (xtensa_default_isa, opcode, opnum,
2737                                    fmt, slot, slotbuf, &val);
2738   (void) xtensa_operand_decode (xtensa_default_isa, opcode, opnum, &val);
2739   return val;
2740 }
2741
2742 \f
2743 /* Checks for rules from xtensa-relax tables.  */
2744
2745 /* The routine xg_instruction_matches_option_term must return TRUE
2746    when a given option term is true.  The meaning of all of the option
2747    terms is given interpretation by this function.  This is needed when
2748    an option depends on the state of a directive, but there are no such
2749    options in use right now.  */
2750
2751 static bfd_boolean
2752 xg_instruction_matches_option_term (TInsn *insn ATTRIBUTE_UNUSED,
2753                                     const ReqOrOption *option)
2754 {
2755   if (strcmp (option->option_name, "realnop") == 0
2756       || strncmp (option->option_name, "IsaUse", 6) == 0)
2757     {
2758       /* These conditions were evaluated statically when building the
2759          relaxation table.  There's no need to reevaluate them now.  */
2760       return TRUE;
2761     }
2762   else
2763     {
2764       as_fatal (_("internal error: unknown option name '%s'"),
2765                 option->option_name);
2766     }
2767 }
2768
2769
2770 static bfd_boolean
2771 xg_instruction_matches_or_options (TInsn *insn,
2772                                    const ReqOrOptionList *or_option)
2773 {
2774   const ReqOrOption *option;
2775   /* Must match each of the AND terms.  */
2776   for (option = or_option; option != NULL; option = option->next)
2777     {
2778       if (xg_instruction_matches_option_term (insn, option))
2779         return TRUE;
2780     }
2781   return FALSE;
2782 }
2783
2784
2785 static bfd_boolean
2786 xg_instruction_matches_options (TInsn *insn, const ReqOptionList *options)
2787 {
2788   const ReqOption *req_options;
2789   /* Must match each of the AND terms.  */
2790   for (req_options = options;
2791        req_options != NULL;
2792        req_options = req_options->next)
2793     {
2794       /* Must match one of the OR clauses.  */
2795       if (!xg_instruction_matches_or_options (insn,
2796                                               req_options->or_option_terms))
2797         return FALSE;
2798     }
2799   return TRUE;
2800 }
2801
2802
2803 /* Return the transition rule that matches or NULL if none matches.  */
2804
2805 static bfd_boolean
2806 xg_instruction_matches_rule (TInsn *insn, TransitionRule *rule)
2807 {
2808   PreconditionList *condition_l;
2809
2810   if (rule->opcode != insn->opcode)
2811     return FALSE;
2812
2813   for (condition_l = rule->conditions;
2814        condition_l != NULL;
2815        condition_l = condition_l->next)
2816     {
2817       expressionS *exp1;
2818       expressionS *exp2;
2819       Precondition *cond = condition_l->precond;
2820
2821       switch (cond->typ)
2822         {
2823         case OP_CONSTANT:
2824           /* The expression must be the constant.  */
2825           assert (cond->op_num < insn->ntok);
2826           exp1 = &insn->tok[cond->op_num];
2827           if (expr_is_const (exp1))
2828             {
2829               switch (cond->cmp)
2830                 {
2831                 case OP_EQUAL:
2832                   if (get_expr_const (exp1) != cond->op_data)
2833                     return FALSE;
2834                   break;
2835                 case OP_NOTEQUAL:
2836                   if (get_expr_const (exp1) == cond->op_data)
2837                     return FALSE;
2838                   break;
2839                 default:
2840                   return FALSE;
2841                 }
2842             }
2843           else if (expr_is_register (exp1))
2844             {
2845               switch (cond->cmp)
2846                 {
2847                 case OP_EQUAL:
2848                   if (get_expr_register (exp1) != cond->op_data)
2849                     return FALSE;
2850                   break;
2851                 case OP_NOTEQUAL:
2852                   if (get_expr_register (exp1) == cond->op_data)
2853                     return FALSE;
2854                   break;
2855                 default:
2856                   return FALSE;
2857                 }
2858             }
2859           else
2860             return FALSE;
2861           break;
2862
2863         case OP_OPERAND:
2864           assert (cond->op_num < insn->ntok);
2865           assert (cond->op_data < insn->ntok);
2866           exp1 = &insn->tok[cond->op_num];
2867           exp2 = &insn->tok[cond->op_data];
2868
2869           switch (cond->cmp)
2870             {
2871             case OP_EQUAL:
2872               if (!expr_is_equal (exp1, exp2))
2873                 return FALSE;
2874               break;
2875             case OP_NOTEQUAL:
2876               if (expr_is_equal (exp1, exp2))
2877                 return FALSE;
2878               break;
2879             }
2880           break;
2881
2882         case OP_LITERAL:
2883         case OP_LABEL:
2884         default:
2885           return FALSE;
2886         }
2887     }
2888   if (!xg_instruction_matches_options (insn, rule->options))
2889     return FALSE;
2890
2891   return TRUE;
2892 }
2893
2894
2895 static int
2896 transition_rule_cmp (const TransitionRule *a, const TransitionRule *b)
2897 {
2898   bfd_boolean a_greater = FALSE;
2899   bfd_boolean b_greater = FALSE;
2900
2901   ReqOptionList *l_a = a->options;
2902   ReqOptionList *l_b = b->options;
2903
2904   /* We only care if they both are the same except for
2905      a const16 vs. an l32r.  */
2906
2907   while (l_a && l_b && ((l_a->next == NULL) == (l_b->next == NULL)))
2908     {
2909       ReqOrOptionList *l_or_a = l_a->or_option_terms;
2910       ReqOrOptionList *l_or_b = l_b->or_option_terms;
2911       while (l_or_a && l_or_b && ((l_a->next == NULL) == (l_b->next == NULL)))
2912         {
2913           if (l_or_a->is_true != l_or_b->is_true)
2914             return 0;
2915           if (strcmp (l_or_a->option_name, l_or_b->option_name) != 0)
2916             {
2917               /* This is the case we care about.  */
2918               if (strcmp (l_or_a->option_name, "IsaUseConst16") == 0
2919                   && strcmp (l_or_b->option_name, "IsaUseL32R") == 0)
2920                 {
2921                   if (prefer_const16)
2922                     a_greater = TRUE;
2923                   else
2924                     b_greater = TRUE;
2925                 }
2926               else if (strcmp (l_or_a->option_name, "IsaUseL32R") == 0
2927                        && strcmp (l_or_b->option_name, "IsaUseConst16") == 0)
2928                 {
2929                   if (prefer_const16)
2930                     b_greater = TRUE;
2931                   else
2932                     a_greater = TRUE;
2933                 }
2934               else
2935                 return 0;
2936             }
2937           l_or_a = l_or_a->next;
2938           l_or_b = l_or_b->next;
2939         }
2940       if (l_or_a || l_or_b)
2941         return 0;
2942
2943       l_a = l_a->next;
2944       l_b = l_b->next;
2945     }
2946   if (l_a || l_b)
2947     return 0;
2948
2949   /* Incomparable if the substitution was used differently in two cases.  */
2950   if (a_greater && b_greater)
2951     return 0;
2952
2953   if (b_greater)
2954     return 1;
2955   if (a_greater)
2956     return -1;
2957
2958   return 0;
2959 }
2960
2961
2962 static TransitionRule *
2963 xg_instruction_match (TInsn *insn)
2964 {
2965   TransitionTable *table = xg_build_simplify_table (&transition_rule_cmp);
2966   TransitionList *l;
2967   assert (insn->opcode < table->num_opcodes);
2968
2969   /* Walk through all of the possible transitions.  */
2970   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
2971     {
2972       TransitionRule *rule = l->rule;
2973       if (xg_instruction_matches_rule (insn, rule))
2974         return rule;
2975     }
2976   return NULL;
2977 }
2978
2979 \f
2980 /* Various Other Internal Functions.  */
2981
2982 static bfd_boolean
2983 is_unique_insn_expansion (TransitionRule *r)
2984 {
2985   if (!r->to_instr || r->to_instr->next != NULL)
2986     return FALSE;
2987   if (r->to_instr->typ != INSTR_INSTR)
2988     return FALSE;
2989   return TRUE;
2990 }
2991
2992
2993 /* Check if there is exactly one relaxation for INSN that converts it to
2994    another instruction of equal or larger size.  If so, and if TARG is
2995    non-null, go ahead and generate the relaxed instruction into TARG.  If
2996    NARROW_ONLY is true, then only consider relaxations that widen a narrow
2997    instruction, i.e., ignore relaxations that convert to an instruction of
2998    equal size.  In some contexts where this function is used, only
2999    a single widening is allowed and the NARROW_ONLY argument is used to
3000    exclude cases like ADDI being "widened" to an ADDMI, which may
3001    later be relaxed to an ADDMI/ADDI pair.  */
3002
3003 bfd_boolean
3004 xg_is_single_relaxable_insn (TInsn *insn, TInsn *targ, bfd_boolean narrow_only)
3005 {
3006   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3007   TransitionList *l;
3008   TransitionRule *match = 0;
3009
3010   assert (insn->insn_type == ITYPE_INSN);
3011   assert (insn->opcode < table->num_opcodes);
3012
3013   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
3014     {
3015       TransitionRule *rule = l->rule;
3016
3017       if (xg_instruction_matches_rule (insn, rule)
3018           && is_unique_insn_expansion (rule)
3019           && (xg_get_single_size (insn->opcode) + (narrow_only ? 1 : 0)
3020               <= xg_get_single_size (rule->to_instr->opcode)))
3021         {
3022           if (match)
3023             return FALSE;
3024           match = rule;
3025         }
3026     }
3027   if (!match)
3028     return FALSE;
3029
3030   if (targ)
3031     xg_build_to_insn (targ, insn, match->to_instr);
3032   return TRUE;
3033 }
3034
3035
3036 /* Return the maximum number of bytes this opcode can expand to.  */
3037
3038 static int
3039 xg_get_max_insn_widen_size (xtensa_opcode opcode)
3040 {
3041   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3042   TransitionList *l;
3043   int max_size = xg_get_single_size (opcode);
3044
3045   assert (opcode < table->num_opcodes);
3046
3047   for (l = table->table[opcode]; l != NULL; l = l->next)
3048     {
3049       TransitionRule *rule = l->rule;
3050       BuildInstr *build_list;
3051       int this_size = 0;
3052
3053       if (!rule)
3054         continue;
3055       build_list = rule->to_instr;
3056       if (is_unique_insn_expansion (rule))
3057         {
3058           assert (build_list->typ == INSTR_INSTR);
3059           this_size = xg_get_max_insn_widen_size (build_list->opcode);
3060         }
3061       else
3062         for (; build_list != NULL; build_list = build_list->next)
3063           {
3064             switch (build_list->typ)
3065               {
3066               case INSTR_INSTR:
3067                 this_size += xg_get_single_size (build_list->opcode);
3068                 break;
3069               case INSTR_LITERAL_DEF:
3070               case INSTR_LABEL_DEF:
3071               default:
3072                 break;
3073               }
3074           }
3075       if (this_size > max_size)
3076         max_size = this_size;
3077     }
3078   return max_size;
3079 }
3080
3081
3082 /* Return the maximum number of literal bytes this opcode can generate.  */
3083
3084 static int
3085 xg_get_max_insn_widen_literal_size (xtensa_opcode opcode)
3086 {
3087   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3088   TransitionList *l;
3089   int max_size = 0;
3090
3091   assert (opcode < table->num_opcodes);
3092
3093   for (l = table->table[opcode]; l != NULL; l = l->next)
3094     {
3095       TransitionRule *rule = l->rule;
3096       BuildInstr *build_list;
3097       int this_size = 0;
3098
3099       if (!rule)
3100         continue;
3101       build_list = rule->to_instr;
3102       if (is_unique_insn_expansion (rule))
3103         {
3104           assert (build_list->typ == INSTR_INSTR);
3105           this_size = xg_get_max_insn_widen_literal_size (build_list->opcode);
3106         }
3107       else
3108         for (; build_list != NULL; build_list = build_list->next)
3109           {
3110             switch (build_list->typ)
3111               {
3112               case INSTR_LITERAL_DEF:
3113                 /* Hard-coded 4-byte literal.  */
3114                 this_size += 4;
3115                 break;
3116               case INSTR_INSTR:
3117               case INSTR_LABEL_DEF:
3118               default:
3119                 break;
3120               }
3121           }
3122       if (this_size > max_size)
3123         max_size = this_size;
3124     }
3125   return max_size;
3126 }
3127
3128
3129 static bfd_boolean
3130 xg_is_relaxable_insn (TInsn *insn, int lateral_steps)
3131 {
3132   int steps_taken = 0;
3133   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3134   TransitionList *l;
3135
3136   assert (insn->insn_type == ITYPE_INSN);
3137   assert (insn->opcode < table->num_opcodes);
3138
3139   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
3140     {
3141       TransitionRule *rule = l->rule;
3142
3143       if (xg_instruction_matches_rule (insn, rule))
3144         {
3145           if (steps_taken == lateral_steps)
3146             return TRUE;
3147           steps_taken++;
3148         }
3149     }
3150   return FALSE;
3151 }
3152
3153
3154 static symbolS *
3155 get_special_literal_symbol (void)
3156 {
3157   static symbolS *sym = NULL;
3158
3159   if (sym == NULL)
3160     sym = symbol_find_or_make ("SPECIAL_LITERAL0\001");
3161   return sym;
3162 }
3163
3164
3165 static symbolS *
3166 get_special_label_symbol (void)
3167 {
3168   static symbolS *sym = NULL;
3169
3170   if (sym == NULL)
3171     sym = symbol_find_or_make ("SPECIAL_LABEL0\001");
3172   return sym;
3173 }
3174
3175
3176 static bfd_boolean
3177 xg_valid_literal_expression (const expressionS *exp)
3178 {
3179   switch (exp->X_op)
3180     {
3181     case O_constant:
3182     case O_symbol:
3183     case O_big:
3184     case O_uminus:
3185     case O_subtract:
3186     case O_pltrel:
3187       return TRUE;
3188     default:
3189       return FALSE;
3190     }
3191 }
3192
3193
3194 /* This will check to see if the value can be converted into the
3195    operand type.  It will return TRUE if it does not fit.  */
3196
3197 static bfd_boolean
3198 xg_check_operand (int32 value, xtensa_opcode opcode, int operand)
3199 {
3200   uint32 valbuf = value;
3201   if (xtensa_operand_encode (xtensa_default_isa, opcode, operand, &valbuf))
3202     return TRUE;
3203   return FALSE;
3204 }
3205
3206
3207 /* Assumes: All immeds are constants.  Check that all constants fit
3208    into their immeds; return FALSE if not.  */
3209
3210 static bfd_boolean
3211 xg_immeds_fit (const TInsn *insn)
3212 {
3213   xtensa_isa isa = xtensa_default_isa;
3214   int i;
3215
3216   int n = insn->ntok;
3217   assert (insn->insn_type == ITYPE_INSN);
3218   for (i = 0; i < n; ++i)
3219     {
3220       const expressionS *expr = &insn->tok[i];
3221       if (xtensa_operand_is_register (isa, insn->opcode, i) == 1)
3222         continue;
3223
3224       switch (expr->X_op)
3225         {
3226         case O_register:
3227         case O_constant:
3228           if (xg_check_operand (expr->X_add_number, insn->opcode, i))
3229             return FALSE;
3230           break;
3231
3232         default:
3233           /* The symbol should have a fixup associated with it.  */
3234           assert (FALSE);
3235           break;
3236         }
3237     }
3238   return TRUE;
3239 }
3240
3241
3242 /* This should only be called after we have an initial
3243    estimate of the addresses.  */
3244
3245 static bfd_boolean
3246 xg_symbolic_immeds_fit (const TInsn *insn,
3247                         segT pc_seg,
3248                         fragS *pc_frag,
3249                         offsetT pc_offset,
3250                         long stretch)
3251 {
3252   xtensa_isa isa = xtensa_default_isa;
3253   symbolS *symbolP;
3254   fragS *sym_frag;
3255   offsetT target, pc;
3256   uint32 new_offset;
3257   int i;
3258   int n = insn->ntok;
3259
3260   assert (insn->insn_type == ITYPE_INSN);
3261
3262   for (i = 0; i < n; ++i)
3263     {
3264       const expressionS *expr = &insn->tok[i];
3265       if (xtensa_operand_is_register (isa, insn->opcode, i) == 1)
3266         continue;
3267
3268       switch (expr->X_op)
3269         {
3270         case O_register:
3271         case O_constant:
3272           if (xg_check_operand (expr->X_add_number, insn->opcode, i))
3273             return FALSE;
3274           break;
3275
3276         case O_lo16:
3277         case O_hi16:
3278           /* Check for the worst case.  */
3279           if (xg_check_operand (0xffff, insn->opcode, i))
3280             return FALSE;
3281           break;
3282
3283         case O_symbol:
3284           /* We only allow symbols for PC-relative references.
3285              If pc_frag == 0, then we don't have frag locations yet.  */
3286           if (pc_frag == 0
3287               || xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 0)
3288             return FALSE;
3289
3290           /* If it is a weak symbol, then assume it won't reach.  */
3291           if (S_IS_WEAK (expr->X_add_symbol))
3292             return FALSE;
3293
3294           if (is_direct_call_opcode (insn->opcode)
3295               && ! pc_frag->tc_frag_data.use_longcalls)
3296             {
3297               /* If callee is undefined or in a different segment, be
3298                  optimistic and assume it will be in range.  */
3299               if (S_GET_SEGMENT (expr->X_add_symbol) != pc_seg)
3300                 return TRUE;
3301             }
3302
3303           /* Only references within a segment can be known to fit in the
3304              operands at assembly time.  */
3305           if (S_GET_SEGMENT (expr->X_add_symbol) != pc_seg)
3306             return FALSE;
3307
3308           symbolP = expr->X_add_symbol;
3309           sym_frag = symbol_get_frag (symbolP);
3310           target = S_GET_VALUE (symbolP) + expr->X_add_number;
3311           pc = pc_frag->fr_address + pc_offset;
3312
3313           /* If frag has yet to be reached on this pass, assume it
3314              will move by STRETCH just as we did.  If this is not so,
3315              it will be because some frag between grows, and that will
3316              force another pass.  Beware zero-length frags.  There
3317              should be a faster way to do this.  */
3318
3319           if (stretch != 0
3320               && sym_frag->relax_marker != pc_frag->relax_marker
3321               && S_GET_SEGMENT (symbolP) == pc_seg)
3322             {
3323               target += stretch;
3324             }
3325
3326           new_offset = target;
3327           xtensa_operand_do_reloc (isa, insn->opcode, i, &new_offset, pc);
3328           if (xg_check_operand (new_offset, insn->opcode, i))
3329             return FALSE;
3330           break;
3331
3332         default:
3333           /* The symbol should have a fixup associated with it.  */
3334           return FALSE;
3335         }
3336     }
3337
3338   return TRUE;
3339 }
3340
3341
3342 /* Return TRUE on success.  */
3343
3344 static bfd_boolean
3345 xg_build_to_insn (TInsn *targ, TInsn *insn, BuildInstr *bi)
3346 {
3347   BuildOp *op;
3348   symbolS *sym;
3349
3350   memset (targ, 0, sizeof (TInsn));
3351   targ->loc = insn->loc;
3352   switch (bi->typ)
3353     {
3354     case INSTR_INSTR:
3355       op = bi->ops;
3356       targ->opcode = bi->opcode;
3357       targ->insn_type = ITYPE_INSN;
3358       targ->is_specific_opcode = FALSE;
3359
3360       for (; op != NULL; op = op->next)
3361         {
3362           int op_num = op->op_num;
3363           int op_data = op->op_data;
3364
3365           assert (op->op_num < MAX_INSN_ARGS);
3366
3367           if (targ->ntok <= op_num)
3368             targ->ntok = op_num + 1;
3369
3370           switch (op->typ)
3371             {
3372             case OP_CONSTANT:
3373               set_expr_const (&targ->tok[op_num], op_data);
3374               break;
3375             case OP_OPERAND:
3376               assert (op_data < insn->ntok);
3377               copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3378               break;
3379             case OP_LITERAL:
3380               sym = get_special_literal_symbol ();
3381               set_expr_symbol_offset (&targ->tok[op_num], sym, 0);
3382               break;
3383             case OP_LABEL:
3384               sym = get_special_label_symbol ();
3385               set_expr_symbol_offset (&targ->tok[op_num], sym, 0);
3386               break;
3387             case OP_OPERAND_HI16U:
3388             case OP_OPERAND_LOW16U:
3389               assert (op_data < insn->ntok);
3390               if (expr_is_const (&insn->tok[op_data]))
3391                 {
3392                   long val;
3393                   copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3394                   val = xg_apply_userdef_op_fn (op->typ,
3395                                                 targ->tok[op_num].
3396                                                 X_add_number);
3397                   targ->tok[op_num].X_add_number = val;
3398                 }
3399               else
3400                 {
3401                   /* For const16 we can create relocations for these.  */
3402                   if (targ->opcode == XTENSA_UNDEFINED
3403                       || (targ->opcode != xtensa_const16_opcode))
3404                     return FALSE;
3405                   assert (op_data < insn->ntok);
3406                   /* Need to build a O_lo16 or O_hi16.  */
3407                   copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3408                   if (targ->tok[op_num].X_op == O_symbol)
3409                     {
3410                       if (op->typ == OP_OPERAND_HI16U)
3411                         targ->tok[op_num].X_op = O_hi16;
3412                       else if (op->typ == OP_OPERAND_LOW16U)
3413                         targ->tok[op_num].X_op = O_lo16;
3414                       else
3415                         return FALSE;
3416                     }
3417                 }
3418               break;
3419             default:
3420               /* currently handles:
3421                  OP_OPERAND_LOW8
3422                  OP_OPERAND_HI24S
3423                  OP_OPERAND_F32MINUS */
3424               if (xg_has_userdef_op_fn (op->typ))
3425                 {
3426                   assert (op_data < insn->ntok);
3427                   if (expr_is_const (&insn->tok[op_data]))
3428                     {
3429                       long val;
3430                       copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3431                       val = xg_apply_userdef_op_fn (op->typ,
3432                                                     targ->tok[op_num].
3433                                                     X_add_number);
3434                       targ->tok[op_num].X_add_number = val;
3435                     }
3436                   else
3437                     return FALSE; /* We cannot use a relocation for this.  */
3438                   break;
3439                 }
3440               assert (0);
3441               break;
3442             }
3443         }
3444       break;
3445
3446     case INSTR_LITERAL_DEF:
3447       op = bi->ops;
3448       targ->opcode = XTENSA_UNDEFINED;
3449       targ->insn_type = ITYPE_LITERAL;
3450       targ->is_specific_opcode = FALSE;
3451       for (; op != NULL; op = op->next)
3452         {
3453           int op_num = op->op_num;
3454           int op_data = op->op_data;
3455           assert (op->op_num < MAX_INSN_ARGS);
3456
3457           if (targ->ntok <= op_num)
3458             targ->ntok = op_num + 1;
3459
3460           switch (op->typ)
3461             {
3462             case OP_OPERAND:
3463               assert (op_data < insn->ntok);
3464               /* We can only pass resolvable literals through.  */
3465               if (!xg_valid_literal_expression (&insn->tok[op_data]))
3466                 return FALSE;
3467               copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3468               break;
3469             case OP_LITERAL:
3470             case OP_CONSTANT:
3471             case OP_LABEL:
3472             default:
3473               assert (0);
3474               break;
3475             }
3476         }
3477       break;
3478
3479     case INSTR_LABEL_DEF:
3480       op = bi->ops;
3481       targ->opcode = XTENSA_UNDEFINED;
3482       targ->insn_type = ITYPE_LABEL;
3483       targ->is_specific_opcode = FALSE;
3484       /* Literal with no ops is a label?  */
3485       assert (op == NULL);
3486       break;
3487
3488     default:
3489       assert (0);
3490     }
3491
3492   return TRUE;
3493 }
3494
3495
3496 /* Return TRUE on success.  */
3497
3498 static bfd_boolean
3499 xg_build_to_stack (IStack *istack, TInsn *insn, BuildInstr *bi)
3500 {
3501   for (; bi != NULL; bi = bi->next)
3502     {
3503       TInsn *next_insn = istack_push_space (istack);
3504
3505       if (!xg_build_to_insn (next_insn, insn, bi))
3506         return FALSE;
3507     }
3508   return TRUE;
3509 }
3510
3511
3512 /* Return TRUE on valid expansion.  */
3513
3514 static bfd_boolean
3515 xg_expand_to_stack (IStack *istack, TInsn *insn, int lateral_steps)
3516 {
3517   int stack_size = istack->ninsn;
3518   int steps_taken = 0;
3519   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3520   TransitionList *l;
3521
3522   assert (insn->insn_type == ITYPE_INSN);
3523   assert (insn->opcode < table->num_opcodes);
3524
3525   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
3526     {
3527       TransitionRule *rule = l->rule;
3528
3529       if (xg_instruction_matches_rule (insn, rule))
3530         {
3531           if (lateral_steps == steps_taken)
3532             {
3533               int i;
3534
3535               /* This is it.  Expand the rule to the stack.  */
3536               if (!xg_build_to_stack (istack, insn, rule->to_instr))
3537                 return FALSE;
3538
3539               /* Check to see if it fits.  */
3540               for (i = stack_size; i < istack->ninsn; i++)
3541                 {
3542                   TInsn *insn = &istack->insn[i];
3543
3544                   if (insn->insn_type == ITYPE_INSN
3545                       && !tinsn_has_symbolic_operands (insn)
3546                       && !xg_immeds_fit (insn))
3547                     {
3548                       istack->ninsn = stack_size;
3549                       return FALSE;
3550                     }
3551                 }
3552               return TRUE;
3553             }
3554           steps_taken++;
3555         }
3556     }
3557   return FALSE;
3558 }
3559
3560 \f
3561 /* Relax the assembly instruction at least "min_steps".
3562    Return the number of steps taken.  */
3563
3564 static int
3565 xg_assembly_relax (IStack *istack,
3566                    TInsn *insn,
3567                    segT pc_seg,
3568                    fragS *pc_frag,      /* if pc_frag == 0, not pc-relative */
3569                    offsetT pc_offset,   /* offset in fragment */
3570                    int min_steps,       /* minimum conversion steps */
3571                    long stretch)        /* number of bytes stretched so far */
3572 {
3573   int steps_taken = 0;
3574
3575   /* assert (has no symbolic operands)
3576      Some of its immeds don't fit.
3577      Try to build a relaxed version.
3578      This may go through a couple of stages
3579      of single instruction transformations before
3580      we get there.  */
3581
3582   TInsn single_target;
3583   TInsn current_insn;
3584   int lateral_steps = 0;
3585   int istack_size = istack->ninsn;
3586
3587   if (xg_symbolic_immeds_fit (insn, pc_seg, pc_frag, pc_offset, stretch)
3588       && steps_taken >= min_steps)
3589     {
3590       istack_push (istack, insn);
3591       return steps_taken;
3592     }
3593   current_insn = *insn;
3594
3595   /* Walk through all of the single instruction expansions.  */
3596   while (xg_is_single_relaxable_insn (&current_insn, &single_target, FALSE))
3597     {
3598       if (xg_symbolic_immeds_fit (&single_target, pc_seg, pc_frag, pc_offset,
3599                                   stretch))
3600         {
3601           steps_taken++;
3602           if (steps_taken >= min_steps)
3603             {
3604               istack_push (istack, &single_target);
3605               return steps_taken;
3606             }
3607         }
3608       current_insn = single_target;
3609     }
3610
3611   /* Now check for a multi-instruction expansion.  */
3612   while (xg_is_relaxable_insn (&current_insn, lateral_steps))
3613     {
3614       if (xg_symbolic_immeds_fit (&current_insn, pc_seg, pc_frag, pc_offset,
3615                                   stretch))
3616         {
3617           if (steps_taken >= min_steps)
3618             {
3619               istack_push (istack, &current_insn);
3620               return steps_taken;
3621             }
3622         }
3623       steps_taken++;
3624       if (xg_expand_to_stack (istack, &current_insn, lateral_steps))
3625         {
3626           if (steps_taken >= min_steps)
3627             return steps_taken;
3628         }
3629       lateral_steps++;
3630       istack->ninsn = istack_size;
3631     }
3632
3633   /* It's not going to work -- use the original.  */
3634   istack_push (istack, insn);
3635   return steps_taken;
3636 }
3637
3638
3639 static void
3640 xg_force_frag_space (int size)
3641 {
3642   /* This may have the side effect of creating a new fragment for the
3643      space to go into.  I just do not like the name of the "frag"
3644      functions.  */
3645   frag_grow (size);
3646 }
3647
3648
3649 static void
3650 xg_finish_frag (char *last_insn,
3651                 enum xtensa_relax_statesE frag_state,
3652                 enum xtensa_relax_statesE slot0_state,
3653                 int max_growth,
3654                 bfd_boolean is_insn)
3655 {
3656   /* Finish off this fragment so that it has at LEAST the desired
3657      max_growth.  If it doesn't fit in this fragment, close this one
3658      and start a new one.  In either case, return a pointer to the
3659      beginning of the growth area.  */
3660
3661   fragS *old_frag;
3662
3663   xg_force_frag_space (max_growth);
3664
3665   old_frag = frag_now;
3666
3667   frag_now->fr_opcode = last_insn;
3668   if (is_insn)
3669     frag_now->tc_frag_data.is_insn = TRUE;
3670
3671   frag_var (rs_machine_dependent, max_growth, max_growth,
3672             frag_state, frag_now->fr_symbol, frag_now->fr_offset, last_insn);
3673
3674   old_frag->tc_frag_data.slot_subtypes[0] = slot0_state;
3675   xtensa_set_frag_assembly_state (frag_now);
3676
3677   /* Just to make sure that we did not split it up.  */
3678   assert (old_frag->fr_next == frag_now);
3679 }
3680
3681
3682 /* Return TRUE if the target frag is one of the next non-empty frags.  */
3683
3684 static bfd_boolean
3685 is_next_frag_target (const fragS *fragP, const fragS *target)
3686 {
3687   if (fragP == NULL)
3688     return FALSE;
3689
3690   for (; fragP; fragP = fragP->fr_next)
3691     {
3692       if (fragP == target)
3693         return TRUE;
3694       if (fragP->fr_fix != 0)
3695         return FALSE;
3696       if (fragP->fr_type == rs_fill && fragP->fr_offset != 0)
3697         return FALSE;
3698       if ((fragP->fr_type == rs_align || fragP->fr_type == rs_align_code)
3699           && ((fragP->fr_address % (1 << fragP->fr_offset)) != 0))
3700         return FALSE;
3701       if (fragP->fr_type == rs_space)
3702         return FALSE;
3703     }
3704   return FALSE;
3705 }
3706
3707
3708 static bfd_boolean
3709 is_branch_jmp_to_next (TInsn *insn, fragS *fragP)
3710 {
3711   xtensa_isa isa = xtensa_default_isa;
3712   int i;
3713   int num_ops = xtensa_opcode_num_operands (isa, insn->opcode);
3714   int target_op = -1;
3715   symbolS *sym;
3716   fragS *target_frag;
3717
3718   if (xtensa_opcode_is_branch (isa, insn->opcode) == 0
3719       && xtensa_opcode_is_jump (isa, insn->opcode) == 0)
3720     return FALSE;
3721
3722   for (i = 0; i < num_ops; i++)
3723     {
3724       if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 1)
3725         {
3726           target_op = i;
3727           break;
3728         }
3729     }
3730   if (target_op == -1)
3731     return FALSE;
3732
3733   if (insn->ntok <= target_op)
3734     return FALSE;
3735
3736   if (insn->tok[target_op].X_op != O_symbol)
3737     return FALSE;
3738
3739   sym = insn->tok[target_op].X_add_symbol;
3740   if (sym == NULL)
3741     return FALSE;
3742
3743   if (insn->tok[target_op].X_add_number != 0)
3744     return FALSE;
3745
3746   target_frag = symbol_get_frag (sym);
3747   if (target_frag == NULL)
3748     return FALSE;
3749
3750   if (is_next_frag_target (fragP->fr_next, target_frag)
3751       && S_GET_VALUE (sym) == target_frag->fr_address)
3752     return TRUE;
3753
3754   return FALSE;
3755 }
3756
3757
3758 static void
3759 xg_add_branch_and_loop_targets (TInsn *insn)
3760 {
3761   xtensa_isa isa = xtensa_default_isa;
3762   int num_ops = xtensa_opcode_num_operands (isa, insn->opcode);
3763
3764   if (xtensa_opcode_is_loop (isa, insn->opcode) == 1)
3765     {
3766       int i = 1;
3767       if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 1
3768           && insn->tok[i].X_op == O_symbol)
3769         symbol_get_tc (insn->tok[i].X_add_symbol)->is_loop_target = TRUE;
3770       return;
3771     }
3772
3773   if (xtensa_opcode_is_branch (isa, insn->opcode) == 1
3774       || xtensa_opcode_is_loop (isa, insn->opcode) == 1)
3775     {
3776       int i;
3777
3778       for (i = 0; i < insn->ntok && i < num_ops; i++)
3779         {
3780           if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 1
3781               && insn->tok[i].X_op == O_symbol)
3782             {
3783               symbolS *sym = insn->tok[i].X_add_symbol;
3784               symbol_get_tc (sym)->is_branch_target = TRUE;
3785               if (S_IS_DEFINED (sym))
3786                 symbol_get_frag (sym)->tc_frag_data.is_branch_target = TRUE;
3787             }
3788         }
3789     }
3790 }
3791
3792
3793 /* Return FALSE if no error.  */
3794
3795 static bfd_boolean
3796 xg_build_token_insn (BuildInstr *instr_spec, TInsn *old_insn, TInsn *new_insn)
3797 {
3798   int num_ops = 0;
3799   BuildOp *b_op;
3800
3801   switch (instr_spec->typ)
3802     {
3803     case INSTR_INSTR:
3804       new_insn->insn_type = ITYPE_INSN;
3805       new_insn->opcode = instr_spec->opcode;
3806       new_insn->is_specific_opcode = FALSE;
3807       new_insn->loc = old_insn->loc;
3808       break;
3809     case INSTR_LITERAL_DEF:
3810       new_insn->insn_type = ITYPE_LITERAL;
3811       new_insn->opcode = XTENSA_UNDEFINED;
3812       new_insn->is_specific_opcode = FALSE;
3813       new_insn->loc = old_insn->loc;
3814       break;
3815     case INSTR_LABEL_DEF:
3816       as_bad (_("INSTR_LABEL_DEF not supported yet"));
3817       break;
3818     }
3819
3820   for (b_op = instr_spec->ops; b_op != NULL; b_op = b_op->next)
3821     {
3822       expressionS *exp;
3823       const expressionS *src_exp;
3824
3825       num_ops++;
3826       switch (b_op->typ)
3827         {
3828         case OP_CONSTANT:
3829           /* The expression must be the constant.  */
3830           assert (b_op->op_num < MAX_INSN_ARGS);
3831           exp = &new_insn->tok[b_op->op_num];
3832           set_expr_const (exp, b_op->op_data);
3833           break;
3834
3835         case OP_OPERAND:
3836           assert (b_op->op_num < MAX_INSN_ARGS);
3837           assert (b_op->op_data < (unsigned) old_insn->ntok);
3838           src_exp = &old_insn->tok[b_op->op_data];
3839           exp = &new_insn->tok[b_op->op_num];
3840           copy_expr (exp, src_exp);
3841           break;
3842
3843         case OP_LITERAL:
3844         case OP_LABEL:
3845           as_bad (_("can't handle generation of literal/labels yet"));
3846           assert (0);
3847
3848         default:
3849           as_bad (_("can't handle undefined OP TYPE"));
3850           assert (0);
3851         }
3852     }
3853
3854   new_insn->ntok = num_ops;
3855   return FALSE;
3856 }
3857
3858
3859 /* Return TRUE if it was simplified.  */
3860
3861 static bfd_boolean
3862 xg_simplify_insn (TInsn *old_insn, TInsn *new_insn)
3863 {
3864   TransitionRule *rule;
3865   BuildInstr *insn_spec;
3866
3867   if (old_insn->is_specific_opcode || !density_supported)
3868     return FALSE;
3869
3870   rule = xg_instruction_match (old_insn);
3871   if (rule == NULL)
3872     return FALSE;
3873
3874   insn_spec = rule->to_instr;
3875   /* There should only be one.  */
3876   assert (insn_spec != NULL);
3877   assert (insn_spec->next == NULL);
3878   if (insn_spec->next != NULL)
3879     return FALSE;
3880
3881   xg_build_token_insn (insn_spec, old_insn, new_insn);
3882
3883   return TRUE;
3884 }
3885
3886
3887 /* xg_expand_assembly_insn: (1) Simplify the instruction, i.e., l32i ->
3888    l32i.n. (2) Check the number of operands.  (3) Place the instruction
3889    tokens into the stack or relax it and place multiple
3890    instructions/literals onto the stack.  Return FALSE if no error.  */
3891
3892 static bfd_boolean
3893 xg_expand_assembly_insn (IStack *istack, TInsn *orig_insn)
3894 {
3895   int noperands;
3896   TInsn new_insn;
3897   bfd_boolean do_expand;
3898
3899   memset (&new_insn, 0, sizeof (TInsn));
3900
3901   /* Narrow it if we can.  xg_simplify_insn now does all the
3902      appropriate checking (e.g., for the density option).  */
3903   if (xg_simplify_insn (orig_insn, &new_insn))
3904     orig_insn = &new_insn;
3905
3906   noperands = xtensa_opcode_num_operands (xtensa_default_isa,
3907                                           orig_insn->opcode);
3908   if (orig_insn->ntok < noperands)
3909     {
3910       as_bad (_("found %d operands for '%s':  Expected %d"),
3911               orig_insn->ntok,
3912               xtensa_opcode_name (xtensa_default_isa, orig_insn->opcode),
3913               noperands);
3914       return TRUE;
3915     }
3916   if (orig_insn->ntok > noperands)
3917     as_warn (_("found too many (%d) operands for '%s':  Expected %d"),
3918              orig_insn->ntok,
3919              xtensa_opcode_name (xtensa_default_isa, orig_insn->opcode),
3920              noperands);
3921
3922   /* If there are not enough operands, we will assert above.  If there
3923      are too many, just cut out the extras here.  */
3924   orig_insn->ntok = noperands;
3925
3926   if (tinsn_has_invalid_symbolic_operands (orig_insn))
3927     return TRUE;
3928
3929   /* If the instruction will definitely need to be relaxed, it is better
3930      to expand it now for better scheduling.  Decide whether to expand
3931      now....  */
3932   do_expand = (!orig_insn->is_specific_opcode && use_transform ());
3933
3934   /* Calls should be expanded to longcalls only in the backend relaxation
3935      so that the assembly scheduler will keep the L32R/CALLX instructions
3936      adjacent.  */
3937   if (is_direct_call_opcode (orig_insn->opcode))
3938     do_expand = FALSE;
3939
3940   if (tinsn_has_symbolic_operands (orig_insn))
3941     {
3942       /* The values of symbolic operands are not known yet, so only expand
3943          now if an operand is "complex" (e.g., difference of symbols) and
3944          will have to be stored as a literal regardless of the value.  */
3945       if (!tinsn_has_complex_operands (orig_insn))
3946         do_expand = FALSE;
3947     }
3948   else if (xg_immeds_fit (orig_insn))
3949     do_expand = FALSE;
3950
3951   if (do_expand)
3952     xg_assembly_relax (istack, orig_insn, 0, 0, 0, 0, 0);
3953   else
3954     istack_push (istack, orig_insn);
3955
3956   return FALSE;
3957 }
3958
3959
3960 /* Return TRUE if the section flags are marked linkonce
3961    or the name is .gnu.linkonce*.  */
3962
3963 static bfd_boolean
3964 get_is_linkonce_section (bfd *abfd ATTRIBUTE_UNUSED, segT sec)
3965 {
3966   flagword flags, link_once_flags;
3967
3968   flags = bfd_get_section_flags (abfd, sec);
3969   link_once_flags = (flags & SEC_LINK_ONCE);
3970
3971   /* Flags might not be set yet.  */
3972   if (!link_once_flags)
3973     {
3974       static size_t len = sizeof ".gnu.linkonce.t.";
3975
3976       if (strncmp (segment_name (sec), ".gnu.linkonce.t.", len - 1) == 0)
3977         link_once_flags = SEC_LINK_ONCE;
3978     }
3979   return (link_once_flags != 0);
3980 }
3981
3982
3983 static void
3984 xtensa_add_literal_sym (symbolS *sym)
3985 {
3986   sym_list *l;
3987
3988   l = (sym_list *) xmalloc (sizeof (sym_list));
3989   l->sym = sym;
3990   l->next = literal_syms;
3991   literal_syms = l;
3992 }
3993
3994
3995 static symbolS *
3996 xtensa_create_literal_symbol (segT sec, fragS *frag)
3997 {
3998   static int lit_num = 0;
3999   static char name[256];
4000   symbolS *symbolP;
4001
4002   sprintf (name, ".L_lit_sym%d", lit_num);
4003
4004   /* Create a local symbol.  If it is in a linkonce section, we have to
4005      be careful to make sure that if it is used in a relocation that the
4006      symbol will be in the output file.  */
4007   if (get_is_linkonce_section (stdoutput, sec))
4008     {
4009       symbolP = symbol_new (name, sec, 0, frag);
4010       S_CLEAR_EXTERNAL (symbolP);
4011       /* symbolP->local = 1; */
4012     }
4013   else
4014     symbolP = symbol_new (name, sec, 0, frag);
4015
4016   xtensa_add_literal_sym (symbolP);
4017
4018   frag->tc_frag_data.is_literal = TRUE;
4019   lit_num++;
4020   return symbolP;
4021 }
4022
4023
4024 /* Currently all literals that are generated here are 32-bit L32R targets.  */
4025
4026 static symbolS *
4027 xg_assemble_literal (/* const */ TInsn *insn)
4028 {
4029   emit_state state;
4030   symbolS *lit_sym = NULL;
4031
4032   /* size = 4 for L32R.  It could easily be larger when we move to
4033      larger constants.  Add a parameter later.  */
4034   offsetT litsize = 4;
4035   offsetT litalign = 2;         /* 2^2 = 4 */
4036   expressionS saved_loc;
4037   expressionS * emit_val;
4038
4039   set_expr_symbol_offset (&saved_loc, frag_now->fr_symbol, frag_now_fix ());
4040
4041   assert (insn->insn_type == ITYPE_LITERAL);
4042   assert (insn->ntok == 1);     /* must be only one token here */
4043
4044   xtensa_switch_to_literal_fragment (&state);
4045
4046   emit_val = &insn->tok[0];
4047   if (emit_val->X_op == O_big)
4048     {
4049       int size = emit_val->X_add_number * CHARS_PER_LITTLENUM;
4050       if (size > litsize)
4051         {
4052           /* This happens when someone writes a "movi a2, big_number".  */
4053           as_bad_where (frag_now->fr_file, frag_now->fr_line,
4054                         _("invalid immediate"));
4055           xtensa_restore_emit_state (&state);
4056           return NULL;
4057         }
4058     }
4059
4060   /* Force a 4-byte align here.  Note that this opens a new frag, so all
4061      literals done with this function have a frag to themselves.  That's
4062      important for the way text section literals work.  */
4063   frag_align (litalign, 0, 0);
4064   record_alignment (now_seg, litalign);
4065
4066   if (emit_val->X_op == O_pltrel)
4067     {
4068       char *p = frag_more (litsize);
4069       xtensa_set_frag_assembly_state (frag_now);
4070       if (emit_val->X_add_symbol)
4071         emit_val->X_op = O_symbol;
4072       else
4073         emit_val->X_op = O_constant;
4074       fix_new_exp (frag_now, p - frag_now->fr_literal,
4075                    litsize, emit_val, 0, BFD_RELOC_XTENSA_PLT);
4076     }
4077   else
4078     emit_expr (emit_val, litsize);
4079
4080   assert (frag_now->tc_frag_data.literal_frag == NULL);
4081   frag_now->tc_frag_data.literal_frag = get_literal_pool_location (now_seg);
4082   frag_now->fr_symbol = xtensa_create_literal_symbol (now_seg, frag_now);
4083   lit_sym = frag_now->fr_symbol;
4084   frag_now->tc_frag_data.is_literal = TRUE;
4085
4086   /* Go back.  */
4087   xtensa_restore_emit_state (&state);
4088   return lit_sym;
4089 }
4090
4091
4092 static void
4093 xg_assemble_literal_space (/* const */ int size, int slot)
4094 {
4095   emit_state state;
4096   /* We might have to do something about this alignment.  It only
4097      takes effect if something is placed here.  */
4098   offsetT litalign = 2;         /* 2^2 = 4 */
4099   fragS *lit_saved_frag;
4100
4101   assert (size % 4 == 0);
4102
4103   xtensa_switch_to_literal_fragment (&state);
4104
4105   /* Force a 4-byte align here.  */
4106   frag_align (litalign, 0, 0);
4107   record_alignment (now_seg, litalign);
4108
4109   xg_force_frag_space (size);
4110
4111   lit_saved_frag = frag_now;
4112   frag_now->tc_frag_data.literal_frag = get_literal_pool_location (now_seg);
4113   frag_now->tc_frag_data.is_literal = TRUE;
4114   frag_now->fr_symbol = xtensa_create_literal_symbol (now_seg, frag_now);
4115   xg_finish_frag (0, RELAX_LITERAL, 0, size, FALSE);
4116
4117   /* Go back.  */
4118   xtensa_restore_emit_state (&state);
4119   frag_now->tc_frag_data.literal_frags[slot] = lit_saved_frag;
4120 }
4121
4122
4123 /* Put in a fixup record based on the opcode.
4124    Return TRUE on success.  */
4125
4126 static bfd_boolean
4127 xg_add_opcode_fix (TInsn *tinsn,
4128                    int opnum,
4129                    xtensa_format fmt,
4130                    int slot,
4131                    expressionS *expr,
4132                    fragS *fragP,
4133                    offsetT offset)
4134 {
4135   xtensa_opcode opcode = tinsn->opcode;
4136   bfd_reloc_code_real_type reloc;
4137   reloc_howto_type *howto;
4138   int fmt_length;
4139   fixS *the_fix;
4140
4141   reloc = BFD_RELOC_NONE;
4142
4143   /* First try the special cases for "alternate" relocs.  */
4144   if (opcode == xtensa_l32r_opcode)
4145     {
4146       if (fragP->tc_frag_data.use_absolute_literals)
4147         reloc = encode_alt_reloc (slot);
4148     }
4149   else if (opcode == xtensa_const16_opcode)
4150     {
4151       if (expr->X_op == O_lo16)
4152         {
4153           reloc = encode_reloc (slot);
4154           expr->X_op = O_symbol;
4155         }
4156       else if (expr->X_op == O_hi16)
4157         {
4158           reloc = encode_alt_reloc (slot);
4159           expr->X_op = O_symbol;
4160         }
4161     }
4162
4163   if (opnum != get_relaxable_immed (opcode))
4164     {
4165       as_bad (_("invalid relocation for operand %i of '%s'"),
4166               opnum, xtensa_opcode_name (xtensa_default_isa, opcode));
4167       return FALSE;
4168     }
4169
4170   /* Handle erroneous "@h" and "@l" expressions here before they propagate
4171      into the symbol table where the generic portions of the assembler
4172      won't know what to do with them.  */
4173   if (expr->X_op == O_lo16 || expr->X_op == O_hi16)
4174     {
4175       as_bad (_("invalid expression for operand %i of '%s'"),
4176               opnum, xtensa_opcode_name (xtensa_default_isa, opcode));
4177       return FALSE;
4178     }
4179
4180   /* Next try the generic relocs.  */
4181   if (reloc == BFD_RELOC_NONE)
4182     reloc = encode_reloc (slot);
4183   if (reloc == BFD_RELOC_NONE)
4184     {
4185       as_bad (_("invalid relocation in instruction slot %i"), slot);
4186       return FALSE;
4187     }
4188
4189   howto = bfd_reloc_type_lookup (stdoutput, reloc);
4190   if (!howto)
4191     {
4192       as_bad (_("undefined symbol for opcode \"%s\""),
4193               xtensa_opcode_name (xtensa_default_isa, opcode));
4194       return FALSE;
4195     }
4196
4197   fmt_length = xtensa_format_length (xtensa_default_isa, fmt);
4198   the_fix = fix_new_exp (fragP, offset, fmt_length, expr,
4199                          howto->pc_relative, reloc);
4200   the_fix->fx_no_overflow = 1;
4201
4202   if (expr->X_add_symbol
4203       && (S_IS_EXTERNAL (expr->X_add_symbol)
4204           || S_IS_WEAK (expr->X_add_symbol)))
4205     the_fix->fx_plt = TRUE;
4206
4207   the_fix->tc_fix_data.X_add_symbol = expr->X_add_symbol;
4208   the_fix->tc_fix_data.X_add_number = expr->X_add_number;
4209   the_fix->tc_fix_data.slot = slot;
4210
4211   return TRUE;
4212 }
4213
4214
4215 static bfd_boolean
4216 xg_emit_insn_to_buf (TInsn *tinsn,
4217                      xtensa_format fmt,
4218                      char *buf,
4219                      fragS *fragP,
4220                      offsetT offset,
4221                      bfd_boolean build_fix)
4222 {
4223   static xtensa_insnbuf insnbuf = NULL;
4224   bfd_boolean has_symbolic_immed = FALSE;
4225   bfd_boolean ok = TRUE;
4226   if (!insnbuf)
4227     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
4228
4229   has_symbolic_immed = tinsn_to_insnbuf (tinsn, insnbuf);
4230   if (has_symbolic_immed && build_fix)
4231     {
4232       /* Add a fixup.  */
4233       int opnum = get_relaxable_immed (tinsn->opcode);
4234       expressionS *exp = &tinsn->tok[opnum];
4235
4236       if (!xg_add_opcode_fix (tinsn, opnum, fmt, 0, exp, fragP, offset))
4237         ok = FALSE;
4238     }
4239   fragP->tc_frag_data.is_insn = TRUE;
4240   xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf,
4241                            (unsigned char *) buf, 0);
4242   return ok;
4243 }
4244
4245
4246 static void
4247 xg_resolve_literals (TInsn *insn, symbolS *lit_sym)
4248 {
4249   symbolS *sym = get_special_literal_symbol ();
4250   int i;
4251   if (lit_sym == 0)
4252     return;
4253   assert (insn->insn_type == ITYPE_INSN);
4254   for (i = 0; i < insn->ntok; i++)
4255     if (insn->tok[i].X_add_symbol == sym)
4256       insn->tok[i].X_add_symbol = lit_sym;
4257
4258 }
4259
4260
4261 static void
4262 xg_resolve_labels (TInsn *insn, symbolS *label_sym)
4263 {
4264   symbolS *sym = get_special_label_symbol ();
4265   int i;
4266   /* assert (!insn->is_literal); */
4267   for (i = 0; i < insn->ntok; i++)
4268     if (insn->tok[i].X_add_symbol == sym)
4269       insn->tok[i].X_add_symbol = label_sym;
4270
4271 }
4272
4273
4274 /* Return TRUE if the instruction can write to the specified
4275    integer register.  */
4276
4277 static bfd_boolean
4278 is_register_writer (const TInsn *insn, const char *regset, int regnum)
4279 {
4280   int i;
4281   int num_ops;
4282   xtensa_isa isa = xtensa_default_isa;
4283
4284   num_ops = xtensa_opcode_num_operands (isa, insn->opcode);
4285
4286   for (i = 0; i < num_ops; i++)
4287     {
4288       char inout;
4289       inout = xtensa_operand_inout (isa, insn->opcode, i);
4290       if ((inout == 'o' || inout == 'm')
4291           && xtensa_operand_is_register (isa, insn->opcode, i) == 1)
4292         {
4293           xtensa_regfile opnd_rf =
4294             xtensa_operand_regfile (isa, insn->opcode, i);
4295           if (!strcmp (xtensa_regfile_shortname (isa, opnd_rf), regset))
4296             {
4297               if ((insn->tok[i].X_op == O_register)
4298                   && (insn->tok[i].X_add_number == regnum))
4299                 return TRUE;
4300             }
4301         }
4302     }
4303   return FALSE;
4304 }
4305
4306
4307 static bfd_boolean
4308 is_bad_loopend_opcode (const TInsn *tinsn)
4309 {
4310   xtensa_opcode opcode = tinsn->opcode;
4311
4312   if (opcode == XTENSA_UNDEFINED)
4313     return FALSE;
4314
4315   if (opcode == xtensa_call0_opcode
4316       || opcode == xtensa_callx0_opcode
4317       || opcode == xtensa_call4_opcode
4318       || opcode == xtensa_callx4_opcode
4319       || opcode == xtensa_call8_opcode
4320       || opcode == xtensa_callx8_opcode
4321       || opcode == xtensa_call12_opcode
4322       || opcode == xtensa_callx12_opcode
4323       || opcode == xtensa_isync_opcode
4324       || opcode == xtensa_ret_opcode
4325       || opcode == xtensa_ret_n_opcode
4326       || opcode == xtensa_retw_opcode
4327       || opcode == xtensa_retw_n_opcode
4328       || opcode == xtensa_waiti_opcode
4329       || opcode == xtensa_rsr_lcount_opcode)
4330     return TRUE;
4331
4332   return FALSE;
4333 }
4334
4335
4336 /* Labels that begin with ".Ln" or ".LM"  are unaligned.
4337    This allows the debugger to add unaligned labels.
4338    Also, the assembler generates stabs labels that need
4339    not be aligned:  FAKE_LABEL_NAME . {"F", "L", "endfunc"}.  */
4340
4341 static bfd_boolean
4342 is_unaligned_label (symbolS *sym)
4343 {
4344   const char *name = S_GET_NAME (sym);
4345   static size_t fake_size = 0;
4346
4347   if (name
4348       && name[0] == '.'
4349       && name[1] == 'L' && (name[2] == 'n' || name[2] == 'M'))
4350     return TRUE;
4351
4352   /* FAKE_LABEL_NAME followed by "F", "L" or "endfunc" */
4353   if (fake_size == 0)
4354     fake_size = strlen (FAKE_LABEL_NAME);
4355
4356   if (name
4357       && strncmp (FAKE_LABEL_NAME, name, fake_size) == 0
4358       && (name[fake_size] == 'F'
4359           || name[fake_size] == 'L'
4360           || (name[fake_size] == 'e'
4361               && strncmp ("endfunc", name+fake_size, 7) == 0)))
4362     return TRUE;
4363
4364   return FALSE;
4365 }
4366
4367
4368 static fragS *
4369 next_non_empty_frag (const fragS *fragP)
4370 {
4371   fragS *next_fragP = fragP->fr_next;
4372
4373   /* Sometimes an empty will end up here due storage allocation issues.
4374      So we have to skip until we find something legit.  */
4375   while (next_fragP && next_fragP->fr_fix == 0)
4376     next_fragP = next_fragP->fr_next;
4377
4378   if (next_fragP == NULL || next_fragP->fr_fix == 0)
4379     return NULL;
4380
4381   return next_fragP;
4382 }
4383
4384
4385 static bfd_boolean
4386 next_frag_opcode_is_loop (const fragS *fragP, xtensa_opcode *opcode)
4387 {
4388   xtensa_opcode out_opcode;
4389   const fragS *next_fragP = next_non_empty_frag (fragP);
4390
4391   if (next_fragP == NULL)
4392     return FALSE;
4393
4394   out_opcode = get_opcode_from_buf (next_fragP->fr_literal, 0);
4395   if (xtensa_opcode_is_loop (xtensa_default_isa, out_opcode) == 1)
4396     {
4397       *opcode = out_opcode;
4398       return TRUE;
4399     }
4400   return FALSE;
4401 }
4402
4403
4404 static int
4405 frag_format_size (const fragS *fragP)
4406 {
4407   static xtensa_insnbuf insnbuf = NULL;
4408   xtensa_isa isa = xtensa_default_isa;
4409   xtensa_format fmt;
4410   int fmt_size;
4411
4412   if (!insnbuf)
4413     insnbuf = xtensa_insnbuf_alloc (isa);
4414
4415   if (fragP == NULL)
4416     return XTENSA_UNDEFINED;
4417
4418   xtensa_insnbuf_from_chars (isa, insnbuf,
4419                              (unsigned char *) fragP->fr_literal, 0);
4420
4421   fmt = xtensa_format_decode (isa, insnbuf);
4422   if (fmt == XTENSA_UNDEFINED)
4423     return XTENSA_UNDEFINED;
4424   fmt_size = xtensa_format_length (isa, fmt);
4425
4426   /* If the next format won't be changing due to relaxation, just
4427      return the length of the first format.  */
4428   if (fragP->fr_opcode != fragP->fr_literal)
4429     return fmt_size;
4430
4431   /* If during relaxation we have to pull an instruction out of a
4432      multi-slot instruction, we will return the more conservative
4433      number.  This works because alignment on bigger instructions
4434      is more restrictive than alignment on smaller instructions.
4435      This is more conservative than we would like, but it happens
4436      infrequently.  */
4437
4438   if (xtensa_format_num_slots (xtensa_default_isa, fmt) > 1)
4439     return fmt_size;
4440
4441   /* If we aren't doing one of our own relaxations or it isn't
4442      slot-based, then the insn size won't change.  */
4443   if (fragP->fr_type != rs_machine_dependent)
4444     return fmt_size;
4445   if (fragP->fr_subtype != RELAX_SLOTS)
4446     return fmt_size;
4447
4448   /* If an instruction is about to grow, return the longer size.  */
4449   if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP1
4450       || fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP2)
4451     return 3;
4452
4453   if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
4454     return 2 + fragP->tc_frag_data.text_expansion[0];
4455
4456   return fmt_size;
4457 }
4458
4459
4460 static int
4461 next_frag_format_size (const fragS *fragP)
4462 {
4463   const fragS *next_fragP = next_non_empty_frag (fragP);
4464   return frag_format_size (next_fragP);
4465 }
4466
4467
4468 /* If the next legit fragment is an end-of-loop marker,
4469    switch its state so it will instantiate a NOP.  */
4470
4471 static void
4472 update_next_frag_state (fragS *fragP)
4473 {
4474   fragS *next_fragP = fragP->fr_next;
4475   fragS *new_target = NULL;
4476
4477   if (align_targets)
4478     {
4479       /* We are guaranteed there will be one of these...   */
4480       while (!(next_fragP->fr_type == rs_machine_dependent
4481                && (next_fragP->fr_subtype == RELAX_MAYBE_UNREACHABLE
4482                    || next_fragP->fr_subtype == RELAX_UNREACHABLE)))
4483         next_fragP = next_fragP->fr_next;
4484
4485       assert (next_fragP->fr_type == rs_machine_dependent
4486               && (next_fragP->fr_subtype == RELAX_MAYBE_UNREACHABLE
4487                   || next_fragP->fr_subtype == RELAX_UNREACHABLE));
4488
4489       /* ...and one of these.  */
4490       new_target = next_fragP->fr_next;
4491       while (!(new_target->fr_type == rs_machine_dependent
4492                && (new_target->fr_subtype == RELAX_MAYBE_DESIRE_ALIGN
4493                    || new_target->fr_subtype == RELAX_DESIRE_ALIGN)))
4494         new_target = new_target->fr_next;
4495
4496       assert (new_target->fr_type == rs_machine_dependent
4497               && (new_target->fr_subtype == RELAX_MAYBE_DESIRE_ALIGN
4498                   || new_target->fr_subtype == RELAX_DESIRE_ALIGN));
4499     }
4500
4501   while (next_fragP && next_fragP->fr_fix == 0)
4502     {
4503       if (next_fragP->fr_type == rs_machine_dependent
4504           && next_fragP->fr_subtype == RELAX_LOOP_END)
4505         {
4506           next_fragP->fr_subtype = RELAX_LOOP_END_ADD_NOP;
4507           return;
4508         }
4509
4510       next_fragP = next_fragP->fr_next;
4511     }
4512 }
4513
4514
4515 static bfd_boolean
4516 next_frag_is_branch_target (const fragS *fragP)
4517 {
4518   /* Sometimes an empty will end up here due to storage allocation issues,
4519      so we have to skip until we find something legit.  */
4520   for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next)
4521     {
4522       if (fragP->tc_frag_data.is_branch_target)
4523         return TRUE;
4524       if (fragP->fr_fix != 0)
4525         break;
4526     }
4527   return FALSE;
4528 }
4529
4530
4531 static bfd_boolean
4532 next_frag_is_loop_target (const fragS *fragP)
4533 {
4534   /* Sometimes an empty will end up here due storage allocation issues.
4535      So we have to skip until we find something legit. */
4536   for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next)
4537     {
4538       if (fragP->tc_frag_data.is_loop_target)
4539         return TRUE;
4540       if (fragP->fr_fix != 0)
4541         break;
4542     }
4543   return FALSE;
4544 }
4545
4546
4547 static addressT
4548 next_frag_pre_opcode_bytes (const fragS *fragp)
4549 {
4550   const fragS *next_fragp = fragp->fr_next;
4551   xtensa_opcode next_opcode;
4552
4553   if (!next_frag_opcode_is_loop (fragp, &next_opcode))
4554     return 0;
4555
4556   /* Sometimes an empty will end up here due to storage allocation issues,
4557      so we have to skip until we find something legit.  */
4558   while (next_fragp->fr_fix == 0)
4559     next_fragp = next_fragp->fr_next;
4560
4561   if (next_fragp->fr_type != rs_machine_dependent)
4562     return 0;
4563
4564   /* There is some implicit knowledge encoded in here.
4565      The LOOP instructions that are NOT RELAX_IMMED have
4566      been relaxed.  Note that we can assume that the LOOP
4567      instruction is in slot 0 because loops aren't bundleable.  */
4568   if (next_fragp->tc_frag_data.slot_subtypes[0] > RELAX_IMMED)
4569       return get_expanded_loop_offset (next_opcode);
4570
4571   return 0;
4572 }
4573
4574
4575 /* Mark a location where we can later insert literal frags.  Update
4576    the section's literal_pool_loc, so subsequent literals can be
4577    placed nearest to their use.  */
4578
4579 static void
4580 xtensa_mark_literal_pool_location (void)
4581 {
4582   /* Any labels pointing to the current location need
4583      to be adjusted to after the literal pool.  */
4584   emit_state s;
4585   fragS *pool_location;
4586
4587   if (use_literal_section && !directive_state[directive_absolute_literals])
4588     return;
4589
4590   frag_align (2, 0, 0);
4591   record_alignment (now_seg, 2);
4592
4593   /* We stash info in these frags so we can later move the literal's
4594      fixes into this frchain's fix list.  */
4595   pool_location = frag_now;
4596   frag_now->tc_frag_data.lit_frchain = frchain_now;
4597   frag_variant (rs_machine_dependent, 0, 0,
4598                 RELAX_LITERAL_POOL_BEGIN, NULL, 0, NULL);
4599   xtensa_set_frag_assembly_state (frag_now);
4600   frag_now->tc_frag_data.lit_seg = now_seg;
4601   frag_variant (rs_machine_dependent, 0, 0,
4602                 RELAX_LITERAL_POOL_END, NULL, 0, NULL);
4603   xtensa_set_frag_assembly_state (frag_now);
4604
4605   /* Now put a frag into the literal pool that points to this location.  */
4606   set_literal_pool_location (now_seg, pool_location);
4607   xtensa_switch_to_non_abs_literal_fragment (&s);
4608   frag_align (2, 0, 0);
4609   record_alignment (now_seg, 2);
4610
4611   /* Close whatever frag is there.  */
4612   frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
4613   xtensa_set_frag_assembly_state (frag_now);
4614   frag_now->tc_frag_data.literal_frag = pool_location;
4615   frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
4616   xtensa_restore_emit_state (&s);
4617   xtensa_set_frag_assembly_state (frag_now);
4618 }
4619
4620
4621 /* Build a nop of the correct size into tinsn.  */
4622
4623 static void
4624 build_nop (TInsn *tinsn, int size)
4625 {
4626   tinsn_init (tinsn);
4627   switch (size)
4628     {
4629     case 2:
4630       tinsn->opcode = xtensa_nop_n_opcode;
4631       tinsn->ntok = 0;
4632       if (tinsn->opcode == XTENSA_UNDEFINED)
4633         as_fatal (_("opcode 'NOP.N' unavailable in this configuration"));
4634       break;
4635
4636     case 3:
4637       if (xtensa_nop_opcode == XTENSA_UNDEFINED)
4638         {
4639           tinsn->opcode = xtensa_or_opcode;
4640           set_expr_const (&tinsn->tok[0], 1);
4641           set_expr_const (&tinsn->tok[1], 1);
4642           set_expr_const (&tinsn->tok[2], 1);
4643           tinsn->ntok = 3;
4644         }
4645       else
4646         tinsn->opcode = xtensa_nop_opcode;
4647
4648       assert (tinsn->opcode != XTENSA_UNDEFINED);
4649     }
4650 }
4651
4652
4653 /* Assemble a NOP of the requested size in the buffer.  User must have
4654    allocated "buf" with at least "size" bytes.  */
4655
4656 static void
4657 assemble_nop (int size, char *buf)
4658 {
4659   static xtensa_insnbuf insnbuf = NULL;
4660   TInsn tinsn;
4661
4662   build_nop (&tinsn, size);
4663
4664   if (!insnbuf)
4665     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
4666
4667   tinsn_to_insnbuf (&tinsn, insnbuf);
4668   xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf,
4669                            (unsigned char *) buf, 0);
4670 }
4671
4672
4673 /* Return the number of bytes for the offset of the expanded loop
4674    instruction.  This should be incorporated into the relaxation
4675    specification but is hard-coded here.  This is used to auto-align
4676    the loop instruction.  It is invalid to call this function if the
4677    configuration does not have loops or if the opcode is not a loop
4678    opcode.  */
4679
4680 static addressT
4681 get_expanded_loop_offset (xtensa_opcode opcode)
4682 {
4683   /* This is the OFFSET of the loop instruction in the expanded loop.
4684      This MUST correspond directly to the specification of the loop
4685      expansion.  It will be validated on fragment conversion.  */
4686   assert (opcode != XTENSA_UNDEFINED);
4687   if (opcode == xtensa_loop_opcode)
4688     return 0;
4689   if (opcode == xtensa_loopnez_opcode)
4690     return 3;
4691   if (opcode == xtensa_loopgtz_opcode)
4692     return 6;
4693   as_fatal (_("get_expanded_loop_offset: invalid opcode"));
4694   return 0;
4695 }
4696
4697
4698 static fragS *
4699 get_literal_pool_location (segT seg)
4700 {
4701   return seg_info (seg)->tc_segment_info_data.literal_pool_loc;
4702 }
4703
4704
4705 static void
4706 set_literal_pool_location (segT seg, fragS *literal_pool_loc)
4707 {
4708   seg_info (seg)->tc_segment_info_data.literal_pool_loc = literal_pool_loc;
4709 }
4710
4711
4712 /* Set frag assembly state should be called when a new frag is
4713    opened and after a frag has been closed.  */
4714
4715 static void
4716 xtensa_set_frag_assembly_state (fragS *fragP)
4717 {
4718   if (!density_supported)
4719     fragP->tc_frag_data.is_no_density = TRUE;
4720
4721   /* This function is called from subsegs_finish, which is called
4722      after xtensa_end, so we can't use "use_transform" or
4723      "use_schedule" here.  */
4724   if (!directive_state[directive_transform])
4725     fragP->tc_frag_data.is_no_transform = TRUE;
4726   if (directive_state[directive_longcalls])
4727     fragP->tc_frag_data.use_longcalls = TRUE;
4728   fragP->tc_frag_data.use_absolute_literals =
4729     directive_state[directive_absolute_literals];
4730   fragP->tc_frag_data.is_assembly_state_set = TRUE;
4731 }
4732
4733
4734 static bfd_boolean
4735 relaxable_section (asection *sec)
4736 {
4737   return (sec->flags & SEC_DEBUGGING) == 0;
4738 }
4739
4740
4741 static void
4742 xtensa_find_unmarked_state_frags (void)
4743 {
4744   segT *seclist;
4745
4746   /* Walk over each fragment of all of the current segments.  For each
4747      unmarked fragment, mark it with the same info as the previous
4748      fragment.  */
4749   for (seclist = &stdoutput->sections;
4750        seclist && *seclist;
4751        seclist = &(*seclist)->next)
4752     {
4753       segT sec = *seclist;
4754       segment_info_type *seginfo;
4755       fragS *fragP;
4756       flagword flags;
4757       flags = bfd_get_section_flags (stdoutput, sec);
4758       if (flags & SEC_DEBUGGING)
4759         continue;
4760       if (!(flags & SEC_ALLOC))
4761         continue;
4762
4763       seginfo = seg_info (sec);
4764       if (seginfo && seginfo->frchainP)
4765         {
4766           fragS *last_fragP = 0;
4767           for (fragP = seginfo->frchainP->frch_root; fragP;
4768                fragP = fragP->fr_next)
4769             {
4770               if (fragP->fr_fix != 0
4771                   && !fragP->tc_frag_data.is_assembly_state_set)
4772                 {
4773                   if (last_fragP == 0)
4774                     {
4775                       as_warn_where (fragP->fr_file, fragP->fr_line,
4776                                      _("assembly state not set for first frag in section %s"),
4777                                      sec->name);
4778                     }
4779                   else
4780                     {
4781                       fragP->tc_frag_data.is_assembly_state_set = TRUE;
4782                       fragP->tc_frag_data.is_no_density =
4783                         last_fragP->tc_frag_data.is_no_density;
4784                       fragP->tc_frag_data.is_no_transform =
4785                         last_fragP->tc_frag_data.is_no_transform;
4786                       fragP->tc_frag_data.use_longcalls =
4787                         last_fragP->tc_frag_data.use_longcalls;
4788                       fragP->tc_frag_data.use_absolute_literals =
4789                         last_fragP->tc_frag_data.use_absolute_literals;
4790                     }
4791                 }
4792               if (fragP->tc_frag_data.is_assembly_state_set)
4793                 last_fragP = fragP;
4794             }
4795         }
4796     }
4797 }
4798
4799
4800 static void
4801 xtensa_find_unaligned_branch_targets (bfd *abfd ATTRIBUTE_UNUSED,
4802                                       asection *sec,
4803                                       void *unused ATTRIBUTE_UNUSED)
4804 {
4805   flagword flags = bfd_get_section_flags (abfd, sec);
4806   segment_info_type *seginfo = seg_info (sec);
4807   fragS *frag = seginfo->frchainP->frch_root;
4808
4809   if (flags & SEC_CODE)
4810     {
4811       xtensa_isa isa = xtensa_default_isa;
4812       xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa);
4813       while (frag != NULL)
4814         {
4815           if (frag->tc_frag_data.is_branch_target)
4816             {
4817               int op_size;
4818               addressT branch_align, frag_addr;
4819               xtensa_format fmt;
4820
4821               xtensa_insnbuf_from_chars
4822                 (isa, insnbuf, (unsigned char *) frag->fr_literal, 0);
4823               fmt = xtensa_format_decode (isa, insnbuf);
4824               op_size = xtensa_format_length (isa, fmt);
4825               branch_align = 1 << branch_align_power (sec);
4826               frag_addr = frag->fr_address % branch_align;
4827               if (frag_addr + op_size > branch_align)
4828                 as_warn_where (frag->fr_file, frag->fr_line,
4829                                _("unaligned branch target: %d bytes at 0x%lx"),
4830                                op_size, (long) frag->fr_address);
4831             }
4832           frag = frag->fr_next;
4833         }
4834       xtensa_insnbuf_free (isa, insnbuf);
4835     }
4836 }
4837
4838
4839 static void
4840 xtensa_find_unaligned_loops (bfd *abfd ATTRIBUTE_UNUSED,
4841                              asection *sec,
4842                              void *unused ATTRIBUTE_UNUSED)
4843 {
4844   flagword flags = bfd_get_section_flags (abfd, sec);
4845   segment_info_type *seginfo = seg_info (sec);
4846   fragS *frag = seginfo->frchainP->frch_root;
4847   xtensa_isa isa = xtensa_default_isa;
4848
4849   if (flags & SEC_CODE)
4850     {
4851       xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa);
4852       while (frag != NULL)
4853         {
4854           if (frag->tc_frag_data.is_first_loop_insn)
4855             {
4856               int op_size;
4857               addressT frag_addr;
4858               xtensa_format fmt;
4859
4860               xtensa_insnbuf_from_chars
4861                 (isa, insnbuf, (unsigned char *) frag->fr_literal, 0);
4862               fmt = xtensa_format_decode (isa, insnbuf);
4863               op_size = xtensa_format_length (isa, fmt);
4864               frag_addr = frag->fr_address % xtensa_fetch_width;
4865
4866               if (frag_addr + op_size > xtensa_fetch_width)
4867                 as_warn_where (frag->fr_file, frag->fr_line,
4868                                _("unaligned loop: %d bytes at 0x%lx"),
4869                                op_size, (long) frag->fr_address);
4870             }
4871           frag = frag->fr_next;
4872         }
4873       xtensa_insnbuf_free (isa, insnbuf);
4874     }
4875 }
4876
4877
4878 static int
4879 xg_apply_fix_value (fixS *fixP, valueT val)
4880 {
4881   xtensa_isa isa = xtensa_default_isa;
4882   static xtensa_insnbuf insnbuf = NULL;
4883   static xtensa_insnbuf slotbuf = NULL;
4884   xtensa_format fmt;
4885   int slot;
4886   bfd_boolean alt_reloc;
4887   xtensa_opcode opcode;
4888   char *const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
4889
4890   (void) decode_reloc (fixP->fx_r_type, &slot, &alt_reloc);
4891   if (alt_reloc)
4892     as_fatal (_("unexpected fix"));
4893
4894   if (!insnbuf)
4895     {
4896       insnbuf = xtensa_insnbuf_alloc (isa);
4897       slotbuf = xtensa_insnbuf_alloc (isa);
4898     }
4899
4900   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) fixpos, 0);
4901   fmt = xtensa_format_decode (isa, insnbuf);
4902   if (fmt == XTENSA_UNDEFINED)
4903     as_fatal (_("undecodable fix"));
4904   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4905   opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4906   if (opcode == XTENSA_UNDEFINED)
4907     as_fatal (_("undecodable fix"));
4908
4909   /* CONST16 immediates are not PC-relative, despite the fact that we
4910      reuse the normal PC-relative operand relocations for the low part
4911      of a CONST16 operand.  */
4912   if (opcode == xtensa_const16_opcode)
4913     return 0;
4914
4915   xtensa_insnbuf_set_operand (slotbuf, fmt, slot, opcode,
4916                               get_relaxable_immed (opcode), val,
4917                               fixP->fx_file, fixP->fx_line);
4918
4919   xtensa_format_set_slot (isa, fmt, slot, insnbuf, slotbuf);
4920   xtensa_insnbuf_to_chars (isa, insnbuf, (unsigned char *) fixpos, 0);
4921
4922   return 1;
4923 }
4924
4925 \f
4926 /* External Functions and Other GAS Hooks.  */
4927
4928 const char *
4929 xtensa_target_format (void)
4930 {
4931   return (target_big_endian ? "elf32-xtensa-be" : "elf32-xtensa-le");
4932 }
4933
4934
4935 void
4936 xtensa_file_arch_init (bfd *abfd)
4937 {
4938   bfd_set_private_flags (abfd, 0x100 | 0x200);
4939 }
4940
4941
4942 void
4943 md_number_to_chars (char *buf, valueT val, int n)
4944 {
4945   if (target_big_endian)
4946     number_to_chars_bigendian (buf, val, n);
4947   else
4948     number_to_chars_littleendian (buf, val, n);
4949 }
4950
4951
4952 /* This function is called once, at assembler startup time.  It should
4953    set up all the tables, etc. that the MD part of the assembler will
4954    need.  */
4955
4956 void
4957 md_begin (void)
4958 {
4959   segT current_section = now_seg;
4960   int current_subsec = now_subseg;
4961   xtensa_isa isa;
4962
4963   xtensa_default_isa = xtensa_isa_init (0, 0);
4964   isa = xtensa_default_isa;
4965
4966   linkrelax = 1;
4967
4968   /* Set up the .literal, .fini.literal and .init.literal sections.  */
4969   memset (&default_lit_sections, 0, sizeof (default_lit_sections));
4970   default_lit_sections.init_lit_seg_name = INIT_LITERAL_SECTION_NAME;
4971   default_lit_sections.fini_lit_seg_name = FINI_LITERAL_SECTION_NAME;
4972   default_lit_sections.lit_seg_name = LITERAL_SECTION_NAME;
4973   default_lit_sections.lit4_seg_name = LIT4_SECTION_NAME;
4974
4975   subseg_set (current_section, current_subsec);
4976
4977   xg_init_vinsn (&cur_vinsn);
4978
4979   xtensa_addi_opcode = xtensa_opcode_lookup (isa, "addi");
4980   xtensa_addmi_opcode = xtensa_opcode_lookup (isa, "addmi");
4981   xtensa_call0_opcode = xtensa_opcode_lookup (isa, "call0");
4982   xtensa_call4_opcode = xtensa_opcode_lookup (isa, "call4");
4983   xtensa_call8_opcode = xtensa_opcode_lookup (isa, "call8");
4984   xtensa_call12_opcode = xtensa_opcode_lookup (isa, "call12");
4985   xtensa_callx0_opcode = xtensa_opcode_lookup (isa, "callx0");
4986   xtensa_callx4_opcode = xtensa_opcode_lookup (isa, "callx4");
4987   xtensa_callx8_opcode = xtensa_opcode_lookup (isa, "callx8");
4988   xtensa_callx12_opcode = xtensa_opcode_lookup (isa, "callx12");
4989   xtensa_const16_opcode = xtensa_opcode_lookup (isa, "const16");
4990   xtensa_entry_opcode = xtensa_opcode_lookup (isa, "entry");
4991   xtensa_movi_opcode = xtensa_opcode_lookup (isa, "movi");
4992   xtensa_movi_n_opcode = xtensa_opcode_lookup (isa, "movi.n");
4993   xtensa_isync_opcode = xtensa_opcode_lookup (isa, "isync");
4994   xtensa_jx_opcode = xtensa_opcode_lookup (isa, "jx");
4995   xtensa_l32r_opcode = xtensa_opcode_lookup (isa, "l32r");
4996   xtensa_loop_opcode = xtensa_opcode_lookup (isa, "loop");
4997   xtensa_loopnez_opcode = xtensa_opcode_lookup (isa, "loopnez");
4998   xtensa_loopgtz_opcode = xtensa_opcode_lookup (isa, "loopgtz");
4999   xtensa_nop_opcode = xtensa_opcode_lookup (isa, "nop");
5000   xtensa_nop_n_opcode = xtensa_opcode_lookup (isa, "nop.n");
5001   xtensa_or_opcode = xtensa_opcode_lookup (isa, "or");
5002   xtensa_ret_opcode = xtensa_opcode_lookup (isa, "ret");
5003   xtensa_ret_n_opcode = xtensa_opcode_lookup (isa, "ret.n");
5004   xtensa_retw_opcode = xtensa_opcode_lookup (isa, "retw");
5005   xtensa_retw_n_opcode = xtensa_opcode_lookup (isa, "retw.n");
5006   xtensa_rsr_lcount_opcode = xtensa_opcode_lookup (isa, "rsr.lcount");
5007   xtensa_waiti_opcode = xtensa_opcode_lookup (isa, "waiti");
5008
5009   init_op_placement_info_table ();
5010
5011   /* Set up the assembly state.  */
5012   if (!frag_now->tc_frag_data.is_assembly_state_set)
5013     xtensa_set_frag_assembly_state (frag_now);
5014 }
5015
5016
5017 /* TC_INIT_FIX_DATA hook */
5018
5019 void
5020 xtensa_init_fix_data (fixS *x)
5021 {
5022   x->tc_fix_data.slot = 0;
5023   x->tc_fix_data.X_add_symbol = NULL;
5024   x->tc_fix_data.X_add_number = 0;
5025 }
5026
5027
5028 /* tc_frob_label hook */
5029
5030 void
5031 xtensa_frob_label (symbolS *sym)
5032 {
5033   float freq = get_subseg_target_freq (now_seg, now_subseg);
5034
5035   /* Since the label was already attached to a frag associated with the
5036      previous basic block, it now needs to be reset to the current frag.  */
5037   symbol_set_frag (sym, frag_now);
5038   S_SET_VALUE (sym, (valueT) frag_now_fix ());
5039
5040   if (generating_literals)
5041     xtensa_add_literal_sym (sym);
5042   else
5043     xtensa_add_insn_label (sym);
5044
5045   if (symbol_get_tc (sym)->is_loop_target)
5046     {
5047       if ((get_last_insn_flags (now_seg, now_subseg)
5048           & FLAG_IS_BAD_LOOPEND) != 0)
5049         as_bad (_("invalid last instruction for a zero-overhead loop"));
5050
5051       xtensa_set_frag_assembly_state (frag_now);
5052       frag_var (rs_machine_dependent, 4, 4, RELAX_LOOP_END,
5053                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
5054
5055       xtensa_set_frag_assembly_state (frag_now);
5056       xtensa_move_labels (frag_now, 0, TRUE);
5057   }
5058
5059   /* No target aligning in the absolute section.  */
5060   if (now_seg != absolute_section
5061       && do_align_targets ()
5062       && !is_unaligned_label (sym)
5063       && !generating_literals)
5064     {
5065       xtensa_set_frag_assembly_state (frag_now);
5066
5067       frag_var (rs_machine_dependent,
5068                 0, (int) freq,
5069                 RELAX_DESIRE_ALIGN_IF_TARGET,
5070                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
5071       xtensa_set_frag_assembly_state (frag_now);
5072       xtensa_move_labels (frag_now, 0, TRUE);
5073     }
5074
5075   /* We need to mark the following properties even if we aren't aligning.  */
5076
5077   /* If the label is already known to be a branch target, i.e., a
5078      forward branch, mark the frag accordingly.  Backward branches
5079      are handled by xg_add_branch_and_loop_targets.  */
5080   if (symbol_get_tc (sym)->is_branch_target)
5081     symbol_get_frag (sym)->tc_frag_data.is_branch_target = TRUE;
5082
5083   /* Loops only go forward, so they can be identified here.  */
5084   if (symbol_get_tc (sym)->is_loop_target)
5085     symbol_get_frag (sym)->tc_frag_data.is_loop_target = TRUE;
5086 }
5087
5088
5089 /* tc_unrecognized_line hook */
5090
5091 int
5092 xtensa_unrecognized_line (int ch)
5093 {
5094   switch (ch)
5095     {
5096     case '{' :
5097       if (cur_vinsn.inside_bundle == 0)
5098         {
5099           /* PR8110: Cannot emit line number info inside a FLIX bundle
5100              when using --gstabs.  Temporarily disable debug info.  */
5101           generate_lineno_debug ();
5102           if (debug_type == DEBUG_STABS)
5103             {
5104               xt_saved_debug_type = debug_type;
5105               debug_type = DEBUG_NONE;
5106             }
5107
5108           cur_vinsn.inside_bundle = 1;
5109         }
5110       else
5111         {
5112           as_bad (_("extra opening brace"));
5113           return 0;
5114         }
5115       break;
5116
5117     case '}' :
5118       if (cur_vinsn.inside_bundle)
5119         finish_vinsn (&cur_vinsn);
5120       else
5121         {
5122           as_bad (_("extra closing brace"));
5123           return 0;
5124         }
5125       break;
5126     default:
5127       as_bad (_("syntax error"));
5128       return 0;
5129     }
5130   return 1;
5131 }
5132
5133
5134 /* md_flush_pending_output hook */
5135
5136 void
5137 xtensa_flush_pending_output (void)
5138 {
5139   if (cur_vinsn.inside_bundle)
5140     as_bad (_("missing closing brace"));
5141
5142   /* If there is a non-zero instruction fragment, close it.  */
5143   if (frag_now_fix () != 0 && frag_now->tc_frag_data.is_insn)
5144     {
5145       frag_wane (frag_now);
5146       frag_new (0);
5147       xtensa_set_frag_assembly_state (frag_now);
5148     }
5149   frag_now->tc_frag_data.is_insn = FALSE;
5150
5151   xtensa_clear_insn_labels ();
5152 }
5153
5154
5155 /* We had an error while parsing an instruction.  The string might look
5156    like this: "insn arg1, arg2 }".  If so, we need to see the closing
5157    brace and reset some fields.  Otherwise, the vinsn never gets closed
5158    and the num_slots field will grow past the end of the array of slots,
5159    and bad things happen.  */
5160
5161 static void
5162 error_reset_cur_vinsn (void)
5163 {
5164   if (cur_vinsn.inside_bundle)
5165     {
5166       if (*input_line_pointer == '}'
5167           || *(input_line_pointer - 1) == '}'
5168           || *(input_line_pointer - 2) == '}')
5169         xg_clear_vinsn (&cur_vinsn);
5170     }
5171 }
5172
5173
5174 void
5175 md_assemble (char *str)
5176 {
5177   xtensa_isa isa = xtensa_default_isa;
5178   char *opname;
5179   unsigned opnamelen;
5180   bfd_boolean has_underbar = FALSE;
5181   char *arg_strings[MAX_INSN_ARGS];
5182   int num_args;
5183   TInsn orig_insn;              /* Original instruction from the input.  */
5184
5185   tinsn_init (&orig_insn);
5186
5187   /* Split off the opcode.  */
5188   opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/0123456789.");
5189   opname = xmalloc (opnamelen + 1);
5190   memcpy (opname, str, opnamelen);
5191   opname[opnamelen] = '\0';
5192
5193   num_args = tokenize_arguments (arg_strings, str + opnamelen);
5194   if (num_args == -1)
5195     {
5196       as_bad (_("syntax error"));
5197       return;
5198     }
5199
5200   if (xg_translate_idioms (&opname, &num_args, arg_strings))
5201     return;
5202
5203   /* Check for an underbar prefix.  */
5204   if (*opname == '_')
5205     {
5206       has_underbar = TRUE;
5207       opname += 1;
5208     }
5209
5210   orig_insn.insn_type = ITYPE_INSN;
5211   orig_insn.ntok = 0;
5212   orig_insn.is_specific_opcode = (has_underbar || !use_transform ());
5213
5214   orig_insn.opcode = xtensa_opcode_lookup (isa, opname);
5215   if (orig_insn.opcode == XTENSA_UNDEFINED)
5216     {
5217       xtensa_format fmt = xtensa_format_lookup (isa, opname);
5218       if (fmt == XTENSA_UNDEFINED)
5219         {
5220           as_bad (_("unknown opcode or format name '%s'"), opname);
5221           error_reset_cur_vinsn ();
5222           return;
5223         }
5224       if (!cur_vinsn.inside_bundle)
5225         {
5226           as_bad (_("format names only valid inside bundles"));
5227           error_reset_cur_vinsn ();
5228           return;
5229         }
5230       if (cur_vinsn.format != XTENSA_UNDEFINED)
5231         as_warn (_("multiple formats specified for one bundle; using '%s'"),
5232                  opname);
5233       cur_vinsn.format = fmt;
5234       free (has_underbar ? opname - 1 : opname);
5235       error_reset_cur_vinsn ();
5236       return;
5237     }
5238
5239   /* Parse the arguments.  */
5240   if (parse_arguments (&orig_insn, num_args, arg_strings))
5241     {
5242       as_bad (_("syntax error"));
5243       error_reset_cur_vinsn ();
5244       return;
5245     }
5246
5247   /* Free the opcode and argument strings, now that they've been parsed.  */
5248   free (has_underbar ? opname - 1 : opname);
5249   opname = 0;
5250   while (num_args-- > 0)
5251     free (arg_strings[num_args]);
5252
5253   /* Get expressions for invisible operands.  */
5254   if (get_invisible_operands (&orig_insn))
5255     {
5256       error_reset_cur_vinsn ();
5257       return;
5258     }
5259
5260   /* Check for the right number and type of arguments.  */
5261   if (tinsn_check_arguments (&orig_insn))
5262     {
5263       error_reset_cur_vinsn ();
5264       return;
5265     }
5266
5267   dwarf2_where (&orig_insn.loc);
5268
5269   xg_add_branch_and_loop_targets (&orig_insn);
5270
5271   /* Special-case for "entry" instruction.  */
5272   if (orig_insn.opcode == xtensa_entry_opcode)
5273     {
5274       /* Check that the third opcode (#2) is >= 16.  */
5275       if (orig_insn.ntok >= 3)
5276         {
5277           expressionS *exp = &orig_insn.tok[2];
5278           switch (exp->X_op)
5279             {
5280             case O_constant:
5281               if (exp->X_add_number < 16)
5282                 as_warn (_("entry instruction with stack decrement < 16"));
5283               break;
5284
5285             default:
5286               as_warn (_("entry instruction with non-constant decrement"));
5287             }
5288         }
5289     }
5290
5291   /* Finish it off:
5292      assemble_tokens (opcode, tok, ntok);
5293      expand the tokens from the orig_insn into the
5294      stack of instructions that will not expand
5295      unless required at relaxation time.  */
5296
5297   if (!cur_vinsn.inside_bundle)
5298     emit_single_op (&orig_insn);
5299   else /* We are inside a bundle.  */
5300     {
5301       cur_vinsn.slots[cur_vinsn.num_slots] = orig_insn;
5302       cur_vinsn.num_slots++;
5303       if (*input_line_pointer == '}'
5304           || *(input_line_pointer - 1) == '}'
5305           || *(input_line_pointer - 2) == '}')
5306         finish_vinsn (&cur_vinsn);
5307     }
5308
5309   /* We've just emitted a new instruction so clear the list of labels.  */
5310   xtensa_clear_insn_labels ();
5311 }
5312
5313
5314 /* HANDLE_ALIGN hook */
5315
5316 /* For a .align directive, we mark the previous block with the alignment
5317    information.  This will be placed in the object file in the
5318    property section corresponding to this section.  */
5319
5320 void
5321 xtensa_handle_align (fragS *fragP)
5322 {
5323   if (linkrelax
5324       && ! fragP->tc_frag_data.is_literal
5325       && (fragP->fr_type == rs_align
5326           || fragP->fr_type == rs_align_code)
5327       && fragP->fr_address + fragP->fr_fix > 0
5328       && fragP->fr_offset > 0
5329       && now_seg != bss_section)
5330     {
5331       fragP->tc_frag_data.is_align = TRUE;
5332       fragP->tc_frag_data.alignment = fragP->fr_offset;
5333     }
5334
5335   if (fragP->fr_type == rs_align_test)
5336     {
5337       int count;
5338       count = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
5339       if (count != 0)
5340         as_bad_where (fragP->fr_file, fragP->fr_line,
5341                       _("unaligned entry instruction"));
5342     }
5343 }
5344
5345
5346 /* TC_FRAG_INIT hook */
5347
5348 void
5349 xtensa_frag_init (fragS *frag)
5350 {
5351   xtensa_set_frag_assembly_state (frag);
5352 }
5353
5354
5355 symbolS *
5356 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
5357 {
5358   return NULL;
5359 }
5360
5361
5362 /* Round up a section size to the appropriate boundary.  */
5363
5364 valueT
5365 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
5366 {
5367   return size;                  /* Byte alignment is fine.  */
5368 }
5369
5370
5371 long
5372 md_pcrel_from (fixS *fixP)
5373 {
5374   char *insn_p;
5375   static xtensa_insnbuf insnbuf = NULL;
5376   static xtensa_insnbuf slotbuf = NULL;
5377   int opnum;
5378   uint32 opnd_value;
5379   xtensa_opcode opcode;
5380   xtensa_format fmt;
5381   int slot;
5382   xtensa_isa isa = xtensa_default_isa;
5383   valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
5384   bfd_boolean alt_reloc;
5385
5386   if (fixP->fx_r_type == BFD_RELOC_XTENSA_ASM_EXPAND)
5387     return 0;
5388
5389   if (!insnbuf)
5390     {
5391       insnbuf = xtensa_insnbuf_alloc (isa);
5392       slotbuf = xtensa_insnbuf_alloc (isa);
5393     }
5394
5395   insn_p = &fixP->fx_frag->fr_literal[fixP->fx_where];
5396   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) insn_p, 0);
5397   fmt = xtensa_format_decode (isa, insnbuf);
5398
5399   if (fmt == XTENSA_UNDEFINED)
5400     as_fatal (_("bad instruction format"));
5401
5402   if (decode_reloc (fixP->fx_r_type, &slot, &alt_reloc) != 0)
5403     as_fatal (_("invalid relocation"));
5404
5405   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
5406   opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
5407
5408   /* Check for "alternate" relocations (operand not specified).  None
5409      of the current uses for these are really PC-relative.  */
5410   if (alt_reloc || opcode == xtensa_const16_opcode)
5411     {
5412       if (opcode != xtensa_l32r_opcode
5413           && opcode != xtensa_const16_opcode)
5414         as_fatal (_("invalid relocation for '%s' instruction"),
5415                   xtensa_opcode_name (isa, opcode));
5416       return 0;
5417     }
5418
5419   opnum = get_relaxable_immed (opcode);
5420   opnd_value = 0;
5421   if (xtensa_operand_is_PCrelative (isa, opcode, opnum) != 1
5422       || xtensa_operand_do_reloc (isa, opcode, opnum, &opnd_value, addr))
5423     {
5424       as_bad_where (fixP->fx_file,
5425                     fixP->fx_line,
5426                     _("invalid relocation for operand %d of '%s'"),
5427                     opnum, xtensa_opcode_name (isa, opcode));
5428       return 0;
5429     }
5430   return 0 - opnd_value;
5431 }
5432
5433
5434 /* TC_FORCE_RELOCATION hook */
5435
5436 int
5437 xtensa_force_relocation (fixS *fix)
5438 {
5439   switch (fix->fx_r_type)
5440     {
5441     case BFD_RELOC_XTENSA_ASM_EXPAND:
5442     case BFD_RELOC_XTENSA_SLOT0_ALT:
5443     case BFD_RELOC_XTENSA_SLOT1_ALT:
5444     case BFD_RELOC_XTENSA_SLOT2_ALT:
5445     case BFD_RELOC_XTENSA_SLOT3_ALT:
5446     case BFD_RELOC_XTENSA_SLOT4_ALT:
5447     case BFD_RELOC_XTENSA_SLOT5_ALT:
5448     case BFD_RELOC_XTENSA_SLOT6_ALT:
5449     case BFD_RELOC_XTENSA_SLOT7_ALT:
5450     case BFD_RELOC_XTENSA_SLOT8_ALT:
5451     case BFD_RELOC_XTENSA_SLOT9_ALT:
5452     case BFD_RELOC_XTENSA_SLOT10_ALT:
5453     case BFD_RELOC_XTENSA_SLOT11_ALT:
5454     case BFD_RELOC_XTENSA_SLOT12_ALT:
5455     case BFD_RELOC_XTENSA_SLOT13_ALT:
5456     case BFD_RELOC_XTENSA_SLOT14_ALT:
5457       return 1;
5458     default:
5459       break;
5460     }
5461
5462   if (linkrelax && fix->fx_addsy
5463       && relaxable_section (S_GET_SEGMENT (fix->fx_addsy)))
5464     return 1;
5465
5466   return generic_force_reloc (fix);
5467 }
5468
5469
5470 /* TC_VALIDATE_FIX_SUB hook */
5471
5472 int
5473 xtensa_validate_fix_sub (fixS *fix)
5474 {
5475   segT add_symbol_segment, sub_symbol_segment;
5476
5477   /* The difference of two symbols should be resolved by the assembler when
5478      linkrelax is not set.  If the linker may relax the section containing
5479      the symbols, then an Xtensa DIFF relocation must be generated so that
5480      the linker knows to adjust the difference value.  */
5481   if (!linkrelax || fix->fx_addsy == NULL)
5482     return 0;
5483
5484   /* Make sure both symbols are in the same segment, and that segment is
5485      "normal" and relaxable.  If the segment is not "normal", then the
5486      fix is not valid.  If the segment is not "relaxable", then the fix
5487      should have been handled earlier.  */
5488   add_symbol_segment = S_GET_SEGMENT (fix->fx_addsy);
5489   if (! SEG_NORMAL (add_symbol_segment) ||
5490       ! relaxable_section (add_symbol_segment))
5491     return 0;
5492   sub_symbol_segment = S_GET_SEGMENT (fix->fx_subsy);
5493   return (sub_symbol_segment == add_symbol_segment);
5494 }
5495
5496
5497 /* NO_PSEUDO_DOT hook */
5498
5499 /* This function has nothing to do with pseudo dots, but this is the
5500    nearest macro to where the check needs to take place.  FIXME: This
5501    seems wrong.  */
5502
5503 bfd_boolean
5504 xtensa_check_inside_bundle (void)
5505 {
5506   if (cur_vinsn.inside_bundle && input_line_pointer[-1] == '.')
5507     as_bad (_("directives are not valid inside bundles"));
5508
5509   /* This function must always return FALSE because it is called via a
5510      macro that has nothing to do with bundling.  */
5511   return FALSE;
5512 }
5513
5514
5515 /* md_elf_section_change_hook */
5516
5517 void
5518 xtensa_elf_section_change_hook (void)
5519 {
5520   /* Set up the assembly state.  */
5521   if (!frag_now->tc_frag_data.is_assembly_state_set)
5522     xtensa_set_frag_assembly_state (frag_now);
5523 }
5524
5525
5526 /* tc_fix_adjustable hook */
5527
5528 bfd_boolean
5529 xtensa_fix_adjustable (fixS *fixP)
5530 {
5531   /* An offset is not allowed in combination with the difference of two
5532      symbols, but that cannot be easily detected after a local symbol
5533      has been adjusted to a (section+offset) form.  Return 0 so that such
5534      an fix will not be adjusted.  */
5535   if (fixP->fx_subsy && fixP->fx_addsy && fixP->fx_offset
5536       && relaxable_section (S_GET_SEGMENT (fixP->fx_subsy)))
5537     return 0;
5538
5539   /* We need the symbol name for the VTABLE entries.  */
5540   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5541       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5542     return 0;
5543
5544   return 1;
5545 }
5546
5547
5548 void
5549 md_apply_fix3 (fixS *fixP, valueT *valP, segT seg)
5550 {
5551   char *const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
5552   valueT val;
5553
5554   switch (fixP->fx_r_type)
5555     {
5556     case BFD_RELOC_32:
5557     case BFD_RELOC_16:
5558     case BFD_RELOC_8:
5559       if (linkrelax && fixP->fx_subsy)
5560         {
5561           switch (fixP->fx_r_type)
5562             {
5563             case BFD_RELOC_8:
5564               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF8;
5565               break;
5566             case BFD_RELOC_16:
5567               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF16;
5568               break;
5569             case BFD_RELOC_32:
5570               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF32;
5571               break;
5572             default:
5573               break;
5574             }
5575
5576           /* An offset is only allowed when it results from adjusting a
5577              local symbol into a section-relative offset.  If the offset
5578              came from the original expression, tc_fix_adjustable will have
5579              prevented the fix from being converted to a section-relative
5580              form so that we can flag the error here.  */
5581           if (fixP->fx_offset != 0 && !symbol_section_p (fixP->fx_addsy))
5582             as_bad_where (fixP->fx_file, fixP->fx_line,
5583                           _("cannot represent subtraction with an offset"));
5584
5585           val = (S_GET_VALUE (fixP->fx_addsy) + fixP->fx_offset
5586                  - S_GET_VALUE (fixP->fx_subsy));
5587
5588           /* The difference value gets written out, and the DIFF reloc
5589              identifies the address of the subtracted symbol (i.e., the one
5590              with the lowest address).  */
5591           *valP = val;
5592           fixP->fx_offset -= val;
5593           fixP->fx_subsy = NULL;
5594         }
5595       else if (! fixP->fx_addsy)
5596         {
5597           val = *valP;
5598           fixP->fx_done = 1;
5599         }
5600       else
5601         break;
5602       md_number_to_chars (fixpos, val, fixP->fx_size);
5603       fixP->fx_no_overflow = 0; /* Use the standard overflow check.  */
5604       break;
5605
5606     case BFD_RELOC_XTENSA_SLOT0_OP:
5607     case BFD_RELOC_XTENSA_SLOT1_OP:
5608     case BFD_RELOC_XTENSA_SLOT2_OP:
5609     case BFD_RELOC_XTENSA_SLOT3_OP:
5610     case BFD_RELOC_XTENSA_SLOT4_OP:
5611     case BFD_RELOC_XTENSA_SLOT5_OP:
5612     case BFD_RELOC_XTENSA_SLOT6_OP:
5613     case BFD_RELOC_XTENSA_SLOT7_OP:
5614     case BFD_RELOC_XTENSA_SLOT8_OP:
5615     case BFD_RELOC_XTENSA_SLOT9_OP:
5616     case BFD_RELOC_XTENSA_SLOT10_OP:
5617     case BFD_RELOC_XTENSA_SLOT11_OP:
5618     case BFD_RELOC_XTENSA_SLOT12_OP:
5619     case BFD_RELOC_XTENSA_SLOT13_OP:
5620     case BFD_RELOC_XTENSA_SLOT14_OP:
5621       if (linkrelax)
5622         {
5623           /* Write the tentative value of a PC-relative relocation to a
5624              local symbol into the instruction.  The value will be ignored
5625              by the linker, and it makes the object file disassembly
5626              readable when all branch targets are encoded in relocations.  */
5627
5628           assert (fixP->fx_addsy);
5629           if (S_GET_SEGMENT (fixP->fx_addsy) == seg && !fixP->fx_plt
5630               && !S_FORCE_RELOC (fixP->fx_addsy, 1))
5631             {
5632               val = (S_GET_VALUE (fixP->fx_addsy) + fixP->fx_offset
5633                      - md_pcrel_from (fixP));
5634               (void) xg_apply_fix_value (fixP, val);
5635             }
5636         }
5637       else if (! fixP->fx_addsy)
5638         {
5639           val = *valP;
5640           if (xg_apply_fix_value (fixP, val))
5641             fixP->fx_done = 1;
5642         }
5643       break;
5644
5645     case BFD_RELOC_XTENSA_PLT:
5646     case BFD_RELOC_XTENSA_ASM_EXPAND:
5647     case BFD_RELOC_XTENSA_SLOT0_ALT:
5648     case BFD_RELOC_XTENSA_SLOT1_ALT:
5649     case BFD_RELOC_XTENSA_SLOT2_ALT:
5650     case BFD_RELOC_XTENSA_SLOT3_ALT:
5651     case BFD_RELOC_XTENSA_SLOT4_ALT:
5652     case BFD_RELOC_XTENSA_SLOT5_ALT:
5653     case BFD_RELOC_XTENSA_SLOT6_ALT:
5654     case BFD_RELOC_XTENSA_SLOT7_ALT:
5655     case BFD_RELOC_XTENSA_SLOT8_ALT:
5656     case BFD_RELOC_XTENSA_SLOT9_ALT:
5657     case BFD_RELOC_XTENSA_SLOT10_ALT:
5658     case BFD_RELOC_XTENSA_SLOT11_ALT:
5659     case BFD_RELOC_XTENSA_SLOT12_ALT:
5660     case BFD_RELOC_XTENSA_SLOT13_ALT:
5661     case BFD_RELOC_XTENSA_SLOT14_ALT:
5662       /* These all need to be resolved at link-time.  Do nothing now.  */
5663       break;
5664
5665     case BFD_RELOC_VTABLE_INHERIT:
5666     case BFD_RELOC_VTABLE_ENTRY:
5667       fixP->fx_done = 0;
5668       break;
5669
5670     default:
5671       as_bad (_("unhandled local relocation fix %s"),
5672               bfd_get_reloc_code_name (fixP->fx_r_type));
5673     }
5674 }
5675
5676
5677 char *
5678 md_atof (int type, char *litP, int *sizeP)
5679 {
5680   int prec;
5681   LITTLENUM_TYPE words[4];
5682   char *t;
5683   int i;
5684
5685   switch (type)
5686     {
5687     case 'f':
5688       prec = 2;
5689       break;
5690
5691     case 'd':
5692       prec = 4;
5693       break;
5694
5695     default:
5696       *sizeP = 0;
5697       return "bad call to md_atof";
5698     }
5699
5700   t = atof_ieee (input_line_pointer, type, words);
5701   if (t)
5702     input_line_pointer = t;
5703
5704   *sizeP = prec * 2;
5705
5706   for (i = prec - 1; i >= 0; i--)
5707     {
5708       int idx = i;
5709       if (target_big_endian)
5710         idx = (prec - 1 - i);
5711
5712       md_number_to_chars (litP, (valueT) words[idx], 2);
5713       litP += 2;
5714     }
5715
5716   return NULL;
5717 }
5718
5719
5720 int
5721 md_estimate_size_before_relax (fragS *fragP, segT seg ATTRIBUTE_UNUSED)
5722 {
5723   return total_frag_text_expansion (fragP);
5724 }
5725
5726
5727 /* Translate internal representation of relocation info to BFD target
5728    format.  */
5729
5730 arelent *
5731 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
5732 {
5733   arelent *reloc;
5734
5735   reloc = (arelent *) xmalloc (sizeof (arelent));
5736   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5737   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5738   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5739
5740   /* Make sure none of our internal relocations make it this far.
5741      They'd better have been fully resolved by this point.  */
5742   assert ((int) fixp->fx_r_type > 0);
5743
5744   reloc->addend = fixp->fx_offset;
5745
5746   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
5747   if (reloc->howto == NULL)
5748     {
5749       as_bad_where (fixp->fx_file, fixp->fx_line,
5750                     _("cannot represent `%s' relocation in object file"),
5751                     bfd_get_reloc_code_name (fixp->fx_r_type));
5752       free (reloc->sym_ptr_ptr);
5753       free (reloc);
5754       return NULL;
5755     }
5756
5757   if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
5758     as_fatal (_("internal error? cannot generate `%s' relocation"),
5759               bfd_get_reloc_code_name (fixp->fx_r_type));
5760
5761   return reloc;
5762 }
5763
5764 \f
5765 /* Checks for resource conflicts between instructions.  */
5766
5767 /* The func unit stuff could be implemented as bit-vectors rather
5768    than the iterative approach here.  If it ends up being too
5769    slow, we will switch it.  */
5770
5771 resource_table *
5772 new_resource_table (void *data,
5773                     int cycles,
5774                     int nu,
5775                     unit_num_copies_func uncf,
5776                     opcode_num_units_func onuf,
5777                     opcode_funcUnit_use_unit_func ouuf,
5778                     opcode_funcUnit_use_stage_func ousf)
5779 {
5780   int i;
5781   resource_table *rt = (resource_table *) xmalloc (sizeof (resource_table));
5782   rt->data = data;
5783   rt->cycles = cycles;
5784   rt->allocated_cycles = cycles;
5785   rt->num_units = nu;
5786   rt->unit_num_copies = uncf;
5787   rt->opcode_num_units = onuf;
5788   rt->opcode_unit_use = ouuf;
5789   rt->opcode_unit_stage = ousf;
5790
5791   rt->units = (char **) xcalloc (cycles, sizeof (char *));
5792   for (i = 0; i < cycles; i++)
5793     rt->units[i] = (char *) xcalloc (nu, sizeof (char));
5794
5795   return rt;
5796 }
5797
5798
5799 void
5800 clear_resource_table (resource_table *rt)
5801 {
5802   int i, j;
5803   for (i = 0; i < rt->allocated_cycles; i++)
5804     for (j = 0; j < rt->num_units; j++)
5805       rt->units[i][j] = 0;
5806 }
5807
5808
5809 /* We never shrink it, just fake it into thinking so.  */
5810
5811 void
5812 resize_resource_table (resource_table *rt, int cycles)
5813 {
5814   int i, old_cycles;
5815
5816   rt->cycles = cycles;
5817   if (cycles <= rt->allocated_cycles)
5818     return;
5819
5820   old_cycles = rt->allocated_cycles;
5821   rt->allocated_cycles = cycles;
5822
5823   rt->units = xrealloc (rt->units, sizeof (char *) * rt->allocated_cycles);
5824   for (i = 0; i < old_cycles; i++)
5825     rt->units[i] = xrealloc (rt->units[i], sizeof (char) * rt->num_units);
5826   for (i = old_cycles; i < cycles; i++)
5827     rt->units[i] = xcalloc (rt->num_units, sizeof (char));
5828 }
5829
5830
5831 bfd_boolean
5832 resources_available (resource_table *rt, xtensa_opcode opcode, int cycle)
5833 {
5834   int i;
5835   int uses = (rt->opcode_num_units) (rt->data, opcode);
5836
5837   for (i = 0; i < uses; i++)
5838     {
5839       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5840       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5841       int copies_in_use = rt->units[stage + cycle][unit];
5842       int copies = (rt->unit_num_copies) (rt->data, unit);
5843       if (copies_in_use >= copies)
5844         return FALSE;
5845     }
5846   return TRUE;
5847 }
5848
5849
5850 void
5851 reserve_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
5852 {
5853   int i;
5854   int uses = (rt->opcode_num_units) (rt->data, opcode);
5855
5856   for (i = 0; i < uses; i++)
5857     {
5858       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5859       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5860       /* Note that this allows resources to be oversubscribed.  That's
5861          essential to the way the optional scheduler works.
5862          resources_available reports when a resource is over-subscribed,
5863          so it's easy to tell.  */
5864       rt->units[stage + cycle][unit]++;
5865     }
5866 }
5867
5868
5869 void
5870 release_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
5871 {
5872   int i;
5873   int uses = (rt->opcode_num_units) (rt->data, opcode);
5874
5875   for (i = 0; i < uses; i++)
5876     {
5877       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5878       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5879       rt->units[stage + cycle][unit]--;
5880       assert (rt->units[stage + cycle][unit] >= 0);
5881     }
5882 }
5883
5884
5885 /* Wrapper functions make parameterized resource reservation
5886    more convenient.  */
5887
5888 int
5889 opcode_funcUnit_use_unit (void *data, xtensa_opcode opcode, int idx)
5890 {
5891   xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
5892   return use->unit;
5893 }
5894
5895
5896 int
5897 opcode_funcUnit_use_stage (void *data, xtensa_opcode opcode, int idx)
5898 {
5899   xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
5900   return use->stage;
5901 }
5902
5903
5904 /* Note that this function does not check issue constraints, but
5905    solely whether the hardware is available to execute the given
5906    instructions together.  It also doesn't check if the tinsns
5907    write the same state, or access the same tieports.  That is
5908    checked by check_t1_t2_reads_and_writes.  */
5909
5910 static bfd_boolean
5911 resources_conflict (vliw_insn *vinsn)
5912 {
5913   int i;
5914   static resource_table *rt = NULL;
5915
5916   /* This is the most common case by far.  Optimize it.  */
5917   if (vinsn->num_slots == 1)
5918     return FALSE;
5919
5920   if (rt == NULL)
5921     {
5922       xtensa_isa isa = xtensa_default_isa;
5923       rt = new_resource_table
5924         (isa, xtensa_isa_num_pipe_stages (isa),
5925          xtensa_isa_num_funcUnits (isa),
5926          (unit_num_copies_func) xtensa_funcUnit_num_copies,
5927          (opcode_num_units_func) xtensa_opcode_num_funcUnit_uses,
5928          opcode_funcUnit_use_unit,
5929          opcode_funcUnit_use_stage);
5930     }
5931
5932   clear_resource_table (rt);
5933
5934   for (i = 0; i < vinsn->num_slots; i++)
5935     {
5936       if (!resources_available (rt, vinsn->slots[i].opcode, 0))
5937         return TRUE;
5938       reserve_resources (rt, vinsn->slots[i].opcode, 0);
5939     }
5940
5941   return FALSE;
5942 }
5943
5944 \f
5945 /* finish_vinsn, emit_single_op and helper functions.  */
5946
5947 static bfd_boolean find_vinsn_conflicts (vliw_insn *);
5948 static xtensa_format xg_find_narrowest_format (vliw_insn *);
5949 static void bundle_single_op (TInsn *);
5950 static void xg_assemble_vliw_tokens (vliw_insn *);
5951
5952
5953 /* We have reached the end of a bundle; emit into the frag.  */
5954
5955 static void
5956 finish_vinsn (vliw_insn *vinsn)
5957 {
5958   IStack slotstack;
5959   int i;
5960   char *file_name;
5961   unsigned line;
5962
5963   if (find_vinsn_conflicts (vinsn))
5964     {
5965       xg_clear_vinsn (vinsn);
5966       return;
5967     }
5968
5969   /* First, find a format that works.  */
5970   if (vinsn->format == XTENSA_UNDEFINED)
5971     vinsn->format = xg_find_narrowest_format (vinsn);
5972
5973   if (vinsn->format == XTENSA_UNDEFINED)
5974     {
5975       as_where (&file_name, &line);
5976       as_bad_where (file_name, line,
5977                     _("couldn't find a valid instruction format"));
5978       fprintf (stderr, _("    ops were: "));
5979       for (i = 0; i < vinsn->num_slots; i++)
5980         fprintf (stderr, _(" %s;"),
5981                  xtensa_opcode_name (xtensa_default_isa,
5982                                      vinsn->slots[i].opcode));
5983       fprintf (stderr, _("\n"));
5984       xg_clear_vinsn (vinsn);
5985       return;
5986     }
5987
5988   if (vinsn->num_slots
5989       != xtensa_format_num_slots (xtensa_default_isa, vinsn->format))
5990     {
5991       as_bad (_("format '%s' allows %d slots, but there are %d opcodes"),
5992               xtensa_format_name (xtensa_default_isa, vinsn->format),
5993               xtensa_format_num_slots (xtensa_default_isa, vinsn->format),
5994               vinsn->num_slots);
5995       xg_clear_vinsn (vinsn);
5996       return;
5997     }
5998
5999   if (resources_conflict (vinsn))
6000     {
6001       as_where (&file_name, &line);
6002       as_bad_where (file_name, line, _("illegal resource usage in bundle"));
6003       fprintf (stderr, "    ops were: ");
6004       for (i = 0; i < vinsn->num_slots; i++)
6005         fprintf (stderr, " %s;",
6006                  xtensa_opcode_name (xtensa_default_isa,
6007                                      vinsn->slots[i].opcode));
6008       fprintf (stderr, "\n");
6009       xg_clear_vinsn (vinsn);
6010       return;
6011     }
6012
6013   for (i = 0; i < vinsn->num_slots; i++)
6014     {
6015       if (vinsn->slots[i].opcode != XTENSA_UNDEFINED)
6016         {
6017           symbolS *lit_sym = NULL;
6018           int j;
6019           bfd_boolean e = FALSE;
6020           bfd_boolean saved_density = density_supported;
6021
6022           /* We don't want to narrow ops inside multi-slot bundles.  */
6023           if (vinsn->num_slots > 1)
6024             density_supported = FALSE;
6025
6026           istack_init (&slotstack);
6027           if (vinsn->slots[i].opcode == xtensa_nop_opcode)
6028             {
6029               vinsn->slots[i].opcode =
6030                 xtensa_format_slot_nop_opcode (xtensa_default_isa,
6031                                                vinsn->format, i);
6032               vinsn->slots[i].ntok = 0;
6033             }
6034
6035           if (xg_expand_assembly_insn (&slotstack, &vinsn->slots[i]))
6036             {
6037               e = TRUE;
6038               continue;
6039             }
6040
6041           density_supported = saved_density;
6042
6043           if (e)
6044             {
6045               xg_clear_vinsn (vinsn);
6046               return;
6047             }
6048
6049           for (j = 0; j < slotstack.ninsn; j++)
6050             {
6051               TInsn *insn = &slotstack.insn[j];
6052               if (insn->insn_type == ITYPE_LITERAL)
6053                 {
6054                   assert (lit_sym == NULL);
6055                   lit_sym = xg_assemble_literal (insn);
6056                 }
6057               else
6058                 {
6059                   assert (insn->insn_type == ITYPE_INSN);
6060                   if (lit_sym)
6061                     xg_resolve_literals (insn, lit_sym);
6062                   if (j != slotstack.ninsn - 1)
6063                     emit_single_op (insn);
6064                 }
6065             }
6066
6067           if (vinsn->num_slots > 1)
6068             {
6069               if (opcode_fits_format_slot
6070                   (slotstack.insn[slotstack.ninsn - 1].opcode,
6071                    vinsn->format, i))
6072                 {
6073                   vinsn->slots[i] = slotstack.insn[slotstack.ninsn - 1];
6074                 }
6075               else
6076                 {
6077                   bundle_single_op (&slotstack.insn[slotstack.ninsn - 1]);
6078                   if (vinsn->format == XTENSA_UNDEFINED)
6079                     vinsn->slots[i].opcode = xtensa_nop_opcode;
6080                   else
6081                     vinsn->slots[i].opcode
6082                       = xtensa_format_slot_nop_opcode (xtensa_default_isa,
6083                                                        vinsn->format, i);
6084
6085                   vinsn->slots[i].ntok = 0;
6086                 }
6087             }
6088           else
6089             {
6090               vinsn->slots[0] = slotstack.insn[slotstack.ninsn - 1];
6091               vinsn->format = XTENSA_UNDEFINED;
6092             }
6093         }
6094     }
6095
6096   /* Now check resource conflicts on the modified bundle.  */
6097   if (resources_conflict (vinsn))
6098     {
6099       as_where (&file_name, &line);
6100       as_bad_where (file_name, line, _("illegal resource usage in bundle"));
6101       fprintf (stderr, "    ops were: ");
6102       for (i = 0; i < vinsn->num_slots; i++)
6103         fprintf (stderr, " %s;",
6104                  xtensa_opcode_name (xtensa_default_isa,
6105                                      vinsn->slots[i].opcode));
6106       fprintf (stderr, "\n");
6107       xg_clear_vinsn (vinsn);
6108       return;
6109     }
6110
6111   /* First, find a format that works.  */
6112   if (vinsn->format == XTENSA_UNDEFINED)
6113       vinsn->format = xg_find_narrowest_format (vinsn);
6114
6115   xg_assemble_vliw_tokens (vinsn);
6116
6117   xg_clear_vinsn (vinsn);
6118 }
6119
6120
6121 /* Given an vliw instruction, what conflicts are there in register
6122    usage and in writes to states and queues?
6123
6124    This function does two things:
6125    1. Reports an error when a vinsn contains illegal combinations
6126       of writes to registers states or queues.
6127    2. Marks individual tinsns as not relaxable if the combination
6128       contains antidependencies.
6129
6130    Job 2 handles things like swap semantics in instructions that need
6131    to be relaxed.  For example,
6132
6133         addi a0, a1, 100000
6134
6135    normally would be relaxed to
6136
6137         l32r a0, some_label
6138         add a0, a1, a0
6139
6140    _but_, if the above instruction is bundled with an a0 reader, e.g.,
6141
6142         { addi a0, a1, 10000 ; add a2, a0, a4 ; }
6143
6144    then we can't relax it into
6145
6146         l32r a0, some_label
6147         { add a0, a1, a0 ; add a2, a0, a4 ; }
6148
6149    because the value of a0 is trashed before the second add can read it.  */
6150
6151 static char check_t1_t2_reads_and_writes (TInsn *, TInsn *);
6152
6153 static bfd_boolean
6154 find_vinsn_conflicts (vliw_insn *vinsn)
6155 {
6156   int i, j;
6157   int branches = 0;
6158   xtensa_isa isa = xtensa_default_isa;
6159
6160   assert (!past_xtensa_end);
6161
6162   for (i = 0 ; i < vinsn->num_slots; i++)
6163     {
6164       TInsn *op1 = &vinsn->slots[i];
6165       if (op1->is_specific_opcode)
6166         op1->keep_wide = TRUE;
6167       else
6168         op1->keep_wide = FALSE;
6169     }
6170
6171   for (i = 0 ; i < vinsn->num_slots; i++)
6172     {
6173       TInsn *op1 = &vinsn->slots[i];
6174
6175       if (xtensa_opcode_is_branch (isa, op1->opcode) == 1)
6176         branches++;
6177
6178       for (j = 0; j < vinsn->num_slots; j++)
6179         {
6180           if (i != j)
6181             {
6182               TInsn *op2 = &vinsn->slots[j];
6183               char conflict_type = check_t1_t2_reads_and_writes (op1, op2);
6184               switch (conflict_type)
6185                 {
6186                 case 'c':
6187                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same register"),
6188                           xtensa_opcode_name (isa, op1->opcode), i,
6189                           xtensa_opcode_name (isa, op2->opcode), j);
6190                   return TRUE;
6191                 case 'd':
6192                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same state"),
6193                           xtensa_opcode_name (isa, op1->opcode), i,
6194                           xtensa_opcode_name (isa, op2->opcode), j);
6195                   return TRUE;
6196                 case 'e':
6197                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same queue"),
6198                           xtensa_opcode_name (isa, op1->opcode), i,
6199                           xtensa_opcode_name (isa, op2->opcode), j);
6200                   return TRUE;
6201                 case 'f':
6202                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) both have volatile queue accesses"),
6203                           xtensa_opcode_name (isa, op1->opcode), i,
6204                           xtensa_opcode_name (isa, op2->opcode), j);
6205                   return TRUE;
6206                 default:
6207                   /* Everything is OK.  */
6208                   break;
6209                 }
6210               op2->is_specific_opcode = (op2->is_specific_opcode
6211                                          || conflict_type == 'a');
6212             }
6213         }
6214     }
6215
6216   if (branches > 1)
6217     {
6218       as_bad (_("multiple branches or jumps in the same bundle"));
6219       return TRUE;
6220     }
6221
6222   return FALSE;
6223 }
6224
6225
6226 /* Check how the state used by t1 and t2 relate.
6227    Cases found are:
6228
6229    case A: t1 reads a register t2 writes (an antidependency within a bundle)
6230    case B: no relationship between what is read and written (both could
6231            read the same reg though)
6232    case C: t1 writes a register t2 writes (a register conflict within a
6233            bundle)
6234    case D: t1 writes a state that t2 also writes
6235    case E: t1 writes a tie queue that t2 also writes
6236    case F: two volatile queue accesses
6237 */
6238
6239 static char
6240 check_t1_t2_reads_and_writes (TInsn *t1, TInsn *t2)
6241 {
6242   xtensa_isa isa = xtensa_default_isa;
6243   xtensa_regfile t1_regfile, t2_regfile;
6244   int t1_reg, t2_reg;
6245   int t1_base_reg, t1_last_reg;
6246   int t2_base_reg, t2_last_reg;
6247   char t1_inout, t2_inout;
6248   int i, j;
6249   char conflict = 'b';
6250   int t1_states;
6251   int t2_states;
6252   int t1_interfaces;
6253   int t2_interfaces;
6254   bfd_boolean t1_volatile = FALSE;
6255   bfd_boolean t2_volatile = FALSE;
6256
6257   /* Check registers.  */
6258   for (j = 0; j < t2->ntok; j++)
6259     {
6260       if (xtensa_operand_is_register (isa, t2->opcode, j) != 1)
6261         continue;
6262
6263       t2_regfile = xtensa_operand_regfile (isa, t2->opcode, j);
6264       t2_base_reg = t2->tok[j].X_add_number;
6265       t2_last_reg = t2_base_reg + xtensa_operand_num_regs (isa, t2->opcode, j);
6266
6267       for (i = 0; i < t1->ntok; i++)
6268         {
6269           if (xtensa_operand_is_register (isa, t1->opcode, i) != 1)
6270             continue;
6271
6272           t1_regfile = xtensa_operand_regfile (isa, t1->opcode, i);
6273
6274           if (t1_regfile != t2_regfile)
6275             continue;
6276
6277           t1_inout = xtensa_operand_inout (isa, t1->opcode, i);
6278           t2_inout = xtensa_operand_inout (isa, t2->opcode, j);
6279
6280           if (xtensa_operand_is_known_reg (isa, t1->opcode, i) == 0
6281               || xtensa_operand_is_known_reg (isa, t2->opcode, j) == 0)
6282             {
6283               if (t1_inout == 'm' || t1_inout == 'o'
6284                   || t2_inout == 'm' || t2_inout == 'o')
6285                 {
6286                   conflict = 'a';
6287                   continue;
6288                 }
6289             }
6290
6291           t1_base_reg = t1->tok[i].X_add_number;
6292           t1_last_reg = (t1_base_reg
6293                          + xtensa_operand_num_regs (isa, t1->opcode, i));
6294
6295           for (t1_reg = t1_base_reg; t1_reg < t1_last_reg; t1_reg++)
6296             {
6297               for (t2_reg = t2_base_reg; t2_reg < t2_last_reg; t2_reg++)
6298                 {
6299                   if (t1_reg != t2_reg)
6300                     continue;
6301
6302                   if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o'))
6303                     {
6304                       conflict = 'a';
6305                       continue;
6306                     }
6307
6308                   if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o'))
6309                     {
6310                       conflict = 'a';
6311                       continue;
6312                     }
6313
6314                   if (t1_inout != 'i' && t2_inout != 'i')
6315                     return 'c';
6316                 }
6317             }
6318         }
6319     }
6320
6321   /* Check states.  */
6322   t1_states = xtensa_opcode_num_stateOperands (isa, t1->opcode);
6323   t2_states = xtensa_opcode_num_stateOperands (isa, t2->opcode);
6324   for (j = 0; j < t2_states; j++)
6325     {
6326       xtensa_state t2_so = xtensa_stateOperand_state (isa, t2->opcode, j);
6327       t2_inout = xtensa_stateOperand_inout (isa, t2->opcode, j);
6328       for (i = 0; i < t1_states; i++)
6329         {
6330           xtensa_state t1_so = xtensa_stateOperand_state (isa, t1->opcode, i);
6331           t1_inout = xtensa_stateOperand_inout (isa, t1->opcode, i);
6332           if (t1_so != t2_so)
6333             continue;
6334
6335           if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o'))
6336             {
6337               conflict = 'a';
6338               continue;
6339             }
6340
6341           if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o'))
6342             {
6343               conflict = 'a';
6344               continue;
6345             }
6346
6347           if (t1_inout != 'i' && t2_inout != 'i')
6348             return 'd';
6349         }
6350     }
6351
6352   /* Check tieports.  */
6353   t1_interfaces = xtensa_opcode_num_interfaceOperands (isa, t1->opcode);
6354   t2_interfaces = xtensa_opcode_num_interfaceOperands (isa, t2->opcode);
6355   for (j = 0; j < t2_interfaces; j++)
6356     {
6357       xtensa_interface t2_int
6358         = xtensa_interfaceOperand_interface (isa, t2->opcode, j);
6359       int t2_class = xtensa_interface_class_id (isa, t2_int);
6360
6361       t2_inout = xtensa_interface_inout (isa, j);
6362       if (xtensa_interface_has_side_effect (isa, t2_int) == 1)
6363         t2_volatile = TRUE;
6364
6365       for (i = 0; i < t1_interfaces; i++)
6366         {
6367           xtensa_interface t1_int
6368             = xtensa_interfaceOperand_interface (isa, t1->opcode, j);
6369           int t1_class = xtensa_interface_class_id (isa, t1_int);
6370
6371           t1_inout = xtensa_interface_inout (isa, i);
6372           if (xtensa_interface_has_side_effect (isa, t1_int) == 1)
6373             t1_volatile = TRUE;
6374
6375           if (t1_volatile && t2_volatile && (t1_class == t2_class))
6376             return 'f';
6377
6378           if (t1_int != t2_int)
6379             continue;
6380
6381           if (t2_inout == 'i' && t1_inout == 'o')
6382             {
6383               conflict = 'a';
6384               continue;
6385             }
6386
6387           if (t1_inout == 'i' && t2_inout == 'o')
6388             {
6389               conflict = 'a';
6390               continue;
6391             }
6392
6393           if (t1_inout != 'i' && t2_inout != 'i')
6394             return 'e';
6395         }
6396     }
6397
6398   return conflict;
6399 }
6400
6401
6402 static xtensa_format
6403 xg_find_narrowest_format (vliw_insn *vinsn)
6404 {
6405   /* Right now we assume that the ops within the vinsn are properly
6406      ordered for the slots that the programmer wanted them in.  In
6407      other words, we don't rearrange the ops in hopes of finding a
6408      better format.  The scheduler handles that.  */
6409
6410   xtensa_isa isa = xtensa_default_isa;
6411   xtensa_format format;
6412   vliw_insn v_copy = *vinsn;
6413   xtensa_opcode nop_opcode = xtensa_nop_opcode;
6414
6415   for (format = 0; format < xtensa_isa_num_formats (isa); format++)
6416     {
6417       v_copy = *vinsn;
6418       if (xtensa_format_num_slots (isa, format) == v_copy.num_slots)
6419         {
6420           int slot;
6421           int fit = 0;
6422           for (slot = 0; slot < v_copy.num_slots; slot++)
6423             {
6424               if (v_copy.slots[slot].opcode == nop_opcode)
6425                 {
6426                   v_copy.slots[slot].opcode =
6427                     xtensa_format_slot_nop_opcode (isa, format, slot);
6428                   v_copy.slots[slot].ntok = 0;
6429                 }
6430
6431               if (opcode_fits_format_slot (v_copy.slots[slot].opcode,
6432                                            format, slot))
6433                 fit++;
6434               else if (v_copy.num_slots > 1)
6435                 {
6436                   TInsn widened;
6437                   /* Try the widened version.  */
6438                   if (!v_copy.slots[slot].keep_wide
6439                       && !v_copy.slots[slot].is_specific_opcode
6440                       && xg_is_single_relaxable_insn (&v_copy.slots[slot],
6441                                                       &widened, TRUE)
6442                       && opcode_fits_format_slot (widened.opcode,
6443                                                   format, slot))
6444                     {
6445                       v_copy.slots[slot] = widened;
6446                       fit++;
6447                     }
6448                 }
6449             }
6450           if (fit == v_copy.num_slots)
6451             {
6452               *vinsn = v_copy;
6453               xtensa_format_encode (isa, format, vinsn->insnbuf);
6454               vinsn->format = format;
6455               break;
6456             }
6457         }
6458     }
6459
6460   if (format == xtensa_isa_num_formats (isa))
6461     return XTENSA_UNDEFINED;
6462
6463   return format;
6464 }
6465
6466
6467 /* Return the additional space needed in a frag
6468    for possible relaxations of any ops in a VLIW insn.
6469    Also fill out the relaxations that might be required of
6470    each tinsn in the vinsn.  */
6471
6472 static int
6473 relaxation_requirements (vliw_insn *vinsn)
6474 {
6475   int extra_space = 0;
6476   int slot;
6477
6478   for (slot = 0; slot < vinsn->num_slots; slot++)
6479     {
6480       TInsn *tinsn = &vinsn->slots[slot];
6481       if (!tinsn_has_symbolic_operands (tinsn))
6482         {
6483           /* A narrow instruction could be widened later to help
6484              alignment issues.  */
6485           if (xg_is_single_relaxable_insn (tinsn, 0, TRUE)
6486               && !tinsn->is_specific_opcode
6487               && vinsn->num_slots == 1)
6488             {
6489               /* Difference in bytes between narrow and wide insns...  */
6490               extra_space += 1;
6491               tinsn->subtype = RELAX_NARROW;
6492               tinsn->record_fix = TRUE;
6493               break;
6494             }
6495           else
6496             {
6497               tinsn->record_fix = FALSE;
6498               /* No extra_space needed.  */
6499             }
6500         }
6501       else
6502         {
6503           if (workaround_b_j_loop_end
6504               && tinsn->opcode == xtensa_jx_opcode
6505               && use_transform ())
6506             {
6507               /* Add 2 of these.  */
6508               extra_space += 3; /* for the nop size */
6509               tinsn->subtype = RELAX_ADD_NOP_IF_PRE_LOOP_END;
6510             }
6511
6512           /* Need to assemble it with space for the relocation.  */
6513           if (xg_is_relaxable_insn (tinsn, 0)
6514               && !tinsn->is_specific_opcode)
6515             {
6516               int max_size = xg_get_max_insn_widen_size (tinsn->opcode);
6517               int max_literal_size =
6518                 xg_get_max_insn_widen_literal_size (tinsn->opcode);
6519
6520               tinsn->literal_space = max_literal_size;
6521
6522               tinsn->subtype = RELAX_IMMED;
6523               tinsn->record_fix = FALSE;
6524               extra_space += max_size;
6525             }
6526           else
6527             {
6528               tinsn->record_fix = TRUE;
6529               /* No extra space needed.  */
6530             }
6531         }
6532     }
6533   return extra_space;
6534 }
6535
6536
6537 static void
6538 bundle_single_op (TInsn *orig_insn)
6539 {
6540   xtensa_isa isa = xtensa_default_isa;
6541   vliw_insn v;
6542   int slot;
6543
6544   xg_init_vinsn (&v);
6545   v.format = op_placement_table[orig_insn->opcode].narrowest;
6546   assert (v.format != XTENSA_UNDEFINED);
6547   v.num_slots = xtensa_format_num_slots (isa, v.format);
6548
6549   for (slot = 0;
6550        !opcode_fits_format_slot (orig_insn->opcode, v.format, slot);
6551        slot++)
6552     {
6553       v.slots[slot].opcode =
6554         xtensa_format_slot_nop_opcode (isa, v.format, slot);
6555       v.slots[slot].ntok = 0;
6556       v.slots[slot].insn_type = ITYPE_INSN;
6557     }
6558
6559   v.slots[slot] = *orig_insn;
6560   slot++;
6561
6562   for ( ; slot < v.num_slots; slot++)
6563     {
6564       v.slots[slot].opcode =
6565         xtensa_format_slot_nop_opcode (isa, v.format, slot);
6566       v.slots[slot].ntok = 0;
6567       v.slots[slot].insn_type = ITYPE_INSN;
6568     }
6569
6570   finish_vinsn (&v);
6571   xg_free_vinsn (&v);
6572 }
6573
6574
6575 static bfd_boolean
6576 emit_single_op (TInsn *orig_insn)
6577 {
6578   int i;
6579   IStack istack;                /* put instructions into here */
6580   symbolS *lit_sym = NULL;
6581   symbolS *label_sym = NULL;
6582
6583   istack_init (&istack);
6584
6585   /* Special-case for "movi aX, foo" which is guaranteed to need relaxing.
6586      Because the scheduling and bundling characteristics of movi and
6587      l32r or const16 are so different, we can do much better if we relax
6588      it prior to scheduling and bundling, rather than after.  */
6589   if ((orig_insn->opcode == xtensa_movi_opcode
6590        || orig_insn->opcode == xtensa_movi_n_opcode)
6591       && !cur_vinsn.inside_bundle
6592       && (orig_insn->tok[1].X_op == O_symbol
6593           || orig_insn->tok[1].X_op == O_pltrel))
6594     xg_assembly_relax (&istack, orig_insn, now_seg, frag_now, 0, 1, 0);
6595   else
6596     if (xg_expand_assembly_insn (&istack, orig_insn))
6597       return TRUE;
6598
6599   for (i = 0; i < istack.ninsn; i++)
6600     {
6601       TInsn *insn = &istack.insn[i];
6602       switch (insn->insn_type)
6603         {
6604         case ITYPE_LITERAL:
6605           assert (lit_sym == NULL);
6606           lit_sym = xg_assemble_literal (insn);
6607           break;
6608         case ITYPE_LABEL:
6609           {
6610             static int relaxed_sym_idx = 0;
6611             char *label = xmalloc (strlen (FAKE_LABEL_NAME) + 12);
6612             sprintf (label, "%s_rl_%x", FAKE_LABEL_NAME, relaxed_sym_idx++);
6613             colon (label);
6614             assert (label_sym == NULL);
6615             label_sym = symbol_find_or_make (label);
6616             assert (label_sym);
6617             free (label);
6618           }
6619           break;
6620         case ITYPE_INSN:
6621           if (lit_sym)
6622             xg_resolve_literals (insn, lit_sym);
6623           if (label_sym)
6624             xg_resolve_labels (insn, label_sym);
6625           bundle_single_op (insn);
6626           break;
6627         default:
6628           assert (0);
6629           break;
6630         }
6631     }
6632   return FALSE;
6633 }
6634
6635
6636 static int
6637 total_frag_text_expansion (fragS *fragP)
6638 {
6639   int slot;
6640   int total_expansion = 0;
6641
6642   for (slot = 0; slot < MAX_SLOTS; slot++)
6643     total_expansion += fragP->tc_frag_data.text_expansion[slot];
6644
6645   return total_expansion;
6646 }
6647
6648
6649 /* Emit a vliw instruction to the current fragment.  */
6650
6651 static void
6652 xg_assemble_vliw_tokens (vliw_insn *vinsn)
6653 {
6654   bfd_boolean finish_frag = FALSE;
6655   bfd_boolean is_jump = FALSE;
6656   bfd_boolean is_branch = FALSE;
6657   xtensa_isa isa = xtensa_default_isa;
6658   int i;
6659   int insn_size;
6660   int extra_space;
6661   char *f = NULL;
6662   int slot;
6663   struct dwarf2_line_info best_loc;
6664
6665   best_loc.line = INT_MAX;
6666
6667   if (generating_literals)
6668     {
6669       static int reported = 0;
6670       if (reported < 4)
6671         as_bad_where (frag_now->fr_file, frag_now->fr_line,
6672                       _("cannot assemble into a literal fragment"));
6673       if (reported == 3)
6674         as_bad (_("..."));
6675       reported++;
6676       return;
6677     }
6678
6679   if (frag_now_fix () != 0
6680       && (! frag_now->tc_frag_data.is_insn
6681           || (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6682           || !use_transform () != frag_now->tc_frag_data.is_no_transform
6683           || (directive_state[directive_longcalls]
6684               != frag_now->tc_frag_data.use_longcalls)
6685           || (directive_state[directive_absolute_literals]
6686               != frag_now->tc_frag_data.use_absolute_literals)))
6687     {
6688       frag_wane (frag_now);
6689       frag_new (0);
6690       xtensa_set_frag_assembly_state (frag_now);
6691     }
6692
6693   if (workaround_a0_b_retw
6694       && vinsn->num_slots == 1
6695       && (get_last_insn_flags (now_seg, now_subseg) & FLAG_IS_A0_WRITER) != 0
6696       && xtensa_opcode_is_branch (isa, vinsn->slots[0].opcode) == 1
6697       && use_transform ())
6698     {
6699       has_a0_b_retw = TRUE;
6700
6701       /* Mark this fragment with the special RELAX_ADD_NOP_IF_A0_B_RETW.
6702          After the first assembly pass we will check all of them and
6703          add a nop if needed.  */
6704       frag_now->tc_frag_data.is_insn = TRUE;
6705       frag_var (rs_machine_dependent, 4, 4,
6706                 RELAX_ADD_NOP_IF_A0_B_RETW,
6707                 frag_now->fr_symbol,
6708                 frag_now->fr_offset,
6709                 NULL);
6710       xtensa_set_frag_assembly_state (frag_now);
6711       frag_now->tc_frag_data.is_insn = TRUE;
6712       frag_var (rs_machine_dependent, 4, 4,
6713                 RELAX_ADD_NOP_IF_A0_B_RETW,
6714                 frag_now->fr_symbol,
6715                 frag_now->fr_offset,
6716                 NULL);
6717       xtensa_set_frag_assembly_state (frag_now);
6718     }
6719
6720   for (i = 0; i < vinsn->num_slots; i++)
6721     {
6722       /* See if the instruction implies an aligned section.  */
6723       if (xtensa_opcode_is_loop (isa, vinsn->slots[i].opcode) == 1)
6724         record_alignment (now_seg, 2);
6725
6726       /* Also determine the best line number for debug info.  */
6727       best_loc = vinsn->slots[i].loc.line < best_loc.line
6728         ? vinsn->slots[i].loc : best_loc;
6729     }
6730
6731   /* Special cases for instructions that force an alignment... */
6732   /* None of these opcodes are bundle-able.  */
6733   if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode) == 1)
6734     {
6735       int max_fill;
6736
6737       xtensa_set_frag_assembly_state (frag_now);
6738       frag_now->tc_frag_data.is_insn = TRUE;
6739
6740       max_fill = get_text_align_max_fill_size
6741         (get_text_align_power (xtensa_fetch_width),
6742          TRUE, frag_now->tc_frag_data.is_no_density);
6743
6744       if (use_transform ())
6745         frag_var (rs_machine_dependent, max_fill, max_fill,
6746                   RELAX_ALIGN_NEXT_OPCODE,
6747                   frag_now->fr_symbol,
6748                   frag_now->fr_offset,
6749                   NULL);
6750       else
6751         frag_var (rs_machine_dependent, 0, 0,
6752                   RELAX_CHECK_ALIGN_NEXT_OPCODE, 0, 0, NULL);
6753       xtensa_set_frag_assembly_state (frag_now);
6754
6755       xtensa_move_labels (frag_now, 0, FALSE);
6756     }
6757
6758   if (vinsn->slots[0].opcode == xtensa_entry_opcode
6759       && !vinsn->slots[0].is_specific_opcode)
6760     {
6761       xtensa_mark_literal_pool_location ();
6762       xtensa_move_labels (frag_now, 0, TRUE);
6763       frag_var (rs_align_test, 1, 1, 0, NULL, 2, NULL);
6764     }
6765
6766   if (vinsn->num_slots == 1)
6767     {
6768       if (workaround_a0_b_retw && use_transform ())
6769         set_last_insn_flags (now_seg, now_subseg, FLAG_IS_A0_WRITER,
6770                              is_register_writer (&vinsn->slots[0], "a", 0));
6771
6772       set_last_insn_flags (now_seg, now_subseg, FLAG_IS_BAD_LOOPEND,
6773                            is_bad_loopend_opcode (&vinsn->slots[0]));
6774     }
6775   else
6776     set_last_insn_flags (now_seg, now_subseg, FLAG_IS_BAD_LOOPEND, FALSE);
6777
6778   insn_size = xtensa_format_length (isa, vinsn->format);
6779
6780   extra_space = relaxation_requirements (vinsn);
6781
6782   /* vinsn_to_insnbuf will produce the error.  */
6783   if (vinsn->format != XTENSA_UNDEFINED)
6784     {
6785       f = frag_more (insn_size + extra_space);
6786       xtensa_set_frag_assembly_state (frag_now);
6787       frag_now->tc_frag_data.is_insn = TRUE;
6788     }
6789
6790   vinsn_to_insnbuf (vinsn, f, frag_now, TRUE);
6791   if (vinsn->format == XTENSA_UNDEFINED)
6792     return;
6793
6794   xtensa_insnbuf_to_chars (isa, vinsn->insnbuf, (unsigned char *) f, 0);
6795
6796   xtensa_dwarf2_emit_insn (insn_size + extra_space, &best_loc);
6797
6798   for (slot = 0; slot < vinsn->num_slots; slot++)
6799     {
6800       TInsn *tinsn = &vinsn->slots[slot];
6801       frag_now->tc_frag_data.slot_subtypes[slot] = tinsn->subtype;
6802       frag_now->tc_frag_data.slot_symbols[slot] = tinsn->symbol;
6803       frag_now->tc_frag_data.slot_sub_symbols[slot] = tinsn->sub_symbol;
6804       frag_now->tc_frag_data.slot_offsets[slot] = tinsn->offset;
6805       frag_now->tc_frag_data.literal_frags[slot] = tinsn->literal_frag;
6806       if (tinsn->literal_space != 0)
6807         xg_assemble_literal_space (tinsn->literal_space, slot);
6808
6809       if (tinsn->subtype == RELAX_NARROW)
6810         assert (vinsn->num_slots == 1);
6811       if (xtensa_opcode_is_jump (isa, tinsn->opcode) == 1)
6812         is_jump = TRUE;
6813       if (xtensa_opcode_is_branch (isa, tinsn->opcode) == 1)
6814         is_branch = TRUE;
6815
6816       if (tinsn->subtype || tinsn->symbol || tinsn->record_fix
6817           || tinsn->offset || tinsn->literal_frag || is_jump || is_branch)
6818         finish_frag = TRUE;
6819     }
6820
6821   if (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6822     frag_now->tc_frag_data.is_specific_opcode = TRUE;
6823
6824   if (finish_frag)
6825     {
6826       frag_variant (rs_machine_dependent,
6827                     extra_space, extra_space, RELAX_SLOTS,
6828                     frag_now->fr_symbol, frag_now->fr_offset, f);
6829       xtensa_set_frag_assembly_state (frag_now);
6830     }
6831
6832   /* Special cases for loops:
6833      close_loop_end should be inserted AFTER short_loop.
6834      Make sure that CLOSE loops are processed BEFORE short_loops
6835      when converting them.  */
6836
6837   /* "short_loop": Add a NOP if the loop is < 4 bytes.  */
6838   if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode)
6839       && !vinsn->slots[0].is_specific_opcode)
6840     {
6841       if (workaround_short_loop && use_transform ())
6842         {
6843           maybe_has_short_loop = TRUE;
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           frag_now->tc_frag_data.is_insn = TRUE;
6849           frag_var (rs_machine_dependent, 4, 4,
6850                     RELAX_ADD_NOP_IF_SHORT_LOOP,
6851                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6852         }
6853
6854       /* "close_loop_end": Add up to 12 bytes of NOPs to keep a
6855          loop at least 12 bytes away from another loop's end.  */
6856       if (workaround_close_loop_end && use_transform ())
6857         {
6858           maybe_has_close_loop_end = TRUE;
6859           frag_now->tc_frag_data.is_insn = TRUE;
6860           frag_var (rs_machine_dependent, 12, 12,
6861                     RELAX_ADD_NOP_IF_CLOSE_LOOP_END,
6862                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6863         }
6864     }
6865
6866   if (use_transform ())
6867     {
6868       if (is_jump)
6869         {
6870           assert (finish_frag);
6871           frag_var (rs_machine_dependent,
6872                     UNREACHABLE_MAX_WIDTH, UNREACHABLE_MAX_WIDTH,
6873                     RELAX_UNREACHABLE,
6874                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6875           xtensa_set_frag_assembly_state (frag_now);
6876         }
6877       else if (is_branch && do_align_targets ())
6878         {
6879           assert (finish_frag);
6880           frag_var (rs_machine_dependent,
6881                     UNREACHABLE_MAX_WIDTH, UNREACHABLE_MAX_WIDTH,
6882                     RELAX_MAYBE_UNREACHABLE,
6883                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6884           xtensa_set_frag_assembly_state (frag_now);
6885           frag_var (rs_machine_dependent,
6886                     0, 0,
6887                     RELAX_MAYBE_DESIRE_ALIGN,
6888                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6889           xtensa_set_frag_assembly_state (frag_now);
6890         }
6891     }
6892
6893   /* Now, if the original opcode was a call...  */
6894   if (do_align_targets ()
6895       && xtensa_opcode_is_call (isa, vinsn->slots[0].opcode) == 1)
6896     {
6897       float freq = get_subseg_total_freq (now_seg, now_subseg);
6898       frag_now->tc_frag_data.is_insn = TRUE;
6899       frag_var (rs_machine_dependent, 4, (int) freq, RELAX_DESIRE_ALIGN,
6900                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
6901       xtensa_set_frag_assembly_state (frag_now);
6902     }
6903
6904   if (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6905     {
6906       frag_wane (frag_now);
6907       frag_new (0);
6908       xtensa_set_frag_assembly_state (frag_now);
6909     }
6910 }
6911
6912 \f
6913 /* xtensa_end and helper functions.  */
6914
6915 static void xtensa_cleanup_align_frags (void);
6916 static void xtensa_fix_target_frags (void);
6917 static void xtensa_mark_narrow_branches (void);
6918 static void xtensa_mark_zcl_first_insns (void);
6919 static void xtensa_fix_a0_b_retw_frags (void);
6920 static void xtensa_fix_b_j_loop_end_frags (void);
6921 static void xtensa_fix_close_loop_end_frags (void);
6922 static void xtensa_fix_short_loop_frags (void);
6923 static void xtensa_sanity_check (void);
6924
6925 void
6926 xtensa_end (void)
6927 {
6928   directive_balance ();
6929   xtensa_flush_pending_output ();
6930
6931   past_xtensa_end = TRUE;
6932
6933   xtensa_move_literals ();
6934
6935   xtensa_reorder_segments ();
6936   xtensa_cleanup_align_frags ();
6937   xtensa_fix_target_frags ();
6938   if (workaround_a0_b_retw && has_a0_b_retw)
6939     xtensa_fix_a0_b_retw_frags ();
6940   if (workaround_b_j_loop_end)
6941     xtensa_fix_b_j_loop_end_frags ();
6942
6943   /* "close_loop_end" should be processed BEFORE "short_loop".  */
6944   if (workaround_close_loop_end && maybe_has_close_loop_end)
6945     xtensa_fix_close_loop_end_frags ();
6946
6947   if (workaround_short_loop && maybe_has_short_loop)
6948     xtensa_fix_short_loop_frags ();
6949   xtensa_mark_narrow_branches ();
6950   xtensa_mark_zcl_first_insns ();
6951
6952   xtensa_sanity_check ();
6953 }
6954
6955
6956 static void
6957 xtensa_cleanup_align_frags (void)
6958 {
6959   frchainS *frchP;
6960
6961   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
6962     {
6963       fragS *fragP;
6964       /* Walk over all of the fragments in a subsection.  */
6965       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
6966         {
6967           if ((fragP->fr_type == rs_align
6968                || fragP->fr_type == rs_align_code
6969                || (fragP->fr_type == rs_machine_dependent
6970                    && (fragP->fr_subtype == RELAX_DESIRE_ALIGN
6971                        || fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)))
6972               && fragP->fr_fix == 0)
6973             {
6974               fragS *next = fragP->fr_next;
6975
6976               while (next
6977                      && next->fr_fix == 0
6978                      && next->fr_type == rs_machine_dependent
6979                      && next->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)
6980                 {
6981                   frag_wane (next);
6982                   next = next->fr_next;
6983                 }
6984             }
6985           /* If we don't widen branch targets, then they
6986              will be easier to align.  */
6987           if (fragP->tc_frag_data.is_branch_target
6988               && fragP->fr_opcode == fragP->fr_literal
6989               && fragP->fr_type == rs_machine_dependent
6990               && fragP->fr_subtype == RELAX_SLOTS
6991               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
6992             frag_wane (fragP);
6993           if (fragP->fr_type == rs_machine_dependent
6994               && fragP->fr_subtype == RELAX_UNREACHABLE)
6995             fragP->tc_frag_data.is_unreachable = TRUE;
6996         }
6997     }
6998 }
6999
7000
7001 /* Re-process all of the fragments looking to convert all of the
7002    RELAX_DESIRE_ALIGN_IF_TARGET fragments.  If there is a branch
7003    target in the next fragment, convert this to RELAX_DESIRE_ALIGN.
7004    Otherwise, convert to a .fill 0.  */
7005
7006 static void
7007 xtensa_fix_target_frags (void)
7008 {
7009   frchainS *frchP;
7010
7011   /* When this routine is called, all of the subsections are still intact
7012      so we walk over subsections instead of sections.  */
7013   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7014     {
7015       fragS *fragP;
7016
7017       /* Walk over all of the fragments in a subsection.  */
7018       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7019         {
7020           if (fragP->fr_type == rs_machine_dependent
7021               && fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)
7022             {
7023               if (next_frag_is_branch_target (fragP))
7024                 fragP->fr_subtype = RELAX_DESIRE_ALIGN;
7025               else
7026                 frag_wane (fragP);
7027             }
7028         }
7029     }
7030 }
7031
7032
7033 static bfd_boolean is_narrow_branch_guaranteed_in_range (fragS *, TInsn *);
7034
7035 static void
7036 xtensa_mark_narrow_branches (void)
7037 {
7038   frchainS *frchP;
7039
7040   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7041     {
7042       fragS *fragP;
7043       /* Walk over all of the fragments in a subsection.  */
7044       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7045         {
7046           if (fragP->fr_type == rs_machine_dependent
7047               && fragP->fr_subtype == RELAX_SLOTS
7048               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED)
7049             {
7050               vliw_insn vinsn;
7051               const expressionS *expr;
7052               symbolS *symbolP;
7053
7054               vinsn_from_chars (&vinsn, fragP->fr_opcode);
7055               tinsn_immed_from_frag (&vinsn.slots[0], fragP, 0);
7056
7057               expr = &vinsn.slots[0].tok[1];
7058               symbolP = expr->X_add_symbol;
7059
7060               if (vinsn.num_slots == 1
7061                   && xtensa_opcode_is_branch (xtensa_default_isa,
7062                                               vinsn.slots[0].opcode)
7063                   && xg_get_single_size (vinsn.slots[0].opcode) == 2
7064                   && is_narrow_branch_guaranteed_in_range (fragP,
7065                                                            &vinsn.slots[0]))
7066                 {
7067                   fragP->fr_subtype = RELAX_SLOTS;
7068                   fragP->tc_frag_data.slot_subtypes[0] = RELAX_NARROW;
7069                 }
7070             }
7071         }
7072     }
7073 }
7074
7075
7076 /* A branch is typically widened only when its target is out of
7077    range.  However, we would like to widen them to align a subsequent
7078    branch target when possible.
7079
7080    Because the branch relaxation code is so convoluted, the optimal solution
7081    (combining the two cases) is difficult to get right in all circumstances.
7082    We therefore go with an "almost as good" solution, where we only
7083    use for alignment narrow branches that definitely will not expand to a
7084    jump and a branch.  These functions find and mark these cases.  */
7085
7086 /* The range in bytes of BNEZ.N and BEQZ.N.  The target operand is encoded
7087    as PC + 4 + imm6, where imm6 is a 6-bit immediate ranging from 0 to 63.
7088    We start counting beginning with the frag after the 2-byte branch, so the
7089    maximum offset is (4 - 2) + 63 = 65.  */
7090 #define MAX_IMMED6 65
7091
7092 static offsetT unrelaxed_frag_max_size (fragS *);
7093
7094 static bfd_boolean
7095 is_narrow_branch_guaranteed_in_range (fragS *fragP, TInsn *tinsn)
7096 {
7097   const expressionS *expr = &tinsn->tok[1];
7098   symbolS *symbolP = expr->X_add_symbol;
7099   fragS *target_frag = symbol_get_frag (symbolP);
7100   offsetT max_distance = expr->X_add_number;
7101   max_distance += (S_GET_VALUE (symbolP) - target_frag->fr_address);
7102   if (is_branch_jmp_to_next (tinsn, fragP))
7103     return FALSE;
7104
7105   /* The branch doesn't branch over it's own frag,
7106      but over the subsequent ones.  */
7107   fragP = fragP->fr_next;
7108   while (fragP != NULL && fragP != target_frag && max_distance <= MAX_IMMED6)
7109     {
7110       max_distance += unrelaxed_frag_max_size (fragP);
7111       fragP = fragP->fr_next;
7112     }
7113   if (max_distance <= MAX_IMMED6 && fragP == target_frag)
7114     return TRUE;
7115   return FALSE;
7116 }
7117
7118
7119 static void
7120 xtensa_mark_zcl_first_insns (void)
7121 {
7122   frchainS *frchP;
7123
7124   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7125     {
7126       fragS *fragP;
7127       /* Walk over all of the fragments in a subsection.  */
7128       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7129         {
7130           if (fragP->fr_type == rs_machine_dependent
7131               && (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE
7132                   || fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE))
7133             {
7134               /* Find the loop frag.  */
7135               fragS *targ_frag = next_non_empty_frag (fragP);
7136               /* Find the first insn frag.  */
7137               targ_frag = next_non_empty_frag (targ_frag);
7138
7139               /* Of course, sometimes (mostly for toy test cases) a
7140                  zero-cost loop instruction is the last in a section.  */
7141               if (targ_frag)
7142                 targ_frag->tc_frag_data.is_first_loop_insn = TRUE;
7143               if (fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE)
7144                 frag_wane (fragP);
7145             }
7146         }
7147     }
7148 }
7149
7150
7151 /* Re-process all of the fragments looking to convert all of the
7152    RELAX_ADD_NOP_IF_A0_B_RETW.  If the next instruction is a
7153    conditional branch or a retw/retw.n, convert this frag to one that
7154    will generate a NOP.  In any case close it off with a .fill 0.  */
7155
7156 static bfd_boolean next_instrs_are_b_retw (fragS *);
7157
7158 static void
7159 xtensa_fix_a0_b_retw_frags (void)
7160 {
7161   frchainS *frchP;
7162
7163   /* When this routine is called, all of the subsections are still intact
7164      so we walk over subsections instead of sections.  */
7165   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7166     {
7167       fragS *fragP;
7168
7169       /* Walk over all of the fragments in a subsection.  */
7170       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7171         {
7172           if (fragP->fr_type == rs_machine_dependent
7173               && fragP->fr_subtype == RELAX_ADD_NOP_IF_A0_B_RETW)
7174             {
7175               if (next_instrs_are_b_retw (fragP))
7176                 {
7177                   if (fragP->tc_frag_data.is_no_transform)
7178                     as_bad (_("instruction sequence (write a0, branch, retw) may trigger hardware errata"));
7179                   else
7180                     relax_frag_add_nop (fragP);
7181                 }
7182               frag_wane (fragP);
7183             }
7184         }
7185     }
7186 }
7187
7188
7189 static bfd_boolean
7190 next_instrs_are_b_retw (fragS *fragP)
7191 {
7192   xtensa_opcode opcode;
7193   xtensa_format fmt;
7194   const fragS *next_fragP = next_non_empty_frag (fragP);
7195   static xtensa_insnbuf insnbuf = NULL;
7196   static xtensa_insnbuf slotbuf = NULL;
7197   xtensa_isa isa = xtensa_default_isa;
7198   int offset = 0;
7199   int slot;
7200   bfd_boolean branch_seen = FALSE;
7201
7202   if (!insnbuf)
7203     {
7204       insnbuf = xtensa_insnbuf_alloc (isa);
7205       slotbuf = xtensa_insnbuf_alloc (isa);
7206     }
7207
7208   if (next_fragP == NULL)
7209     return FALSE;
7210
7211   /* Check for the conditional branch.  */
7212   xtensa_insnbuf_from_chars
7213     (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
7214   fmt = xtensa_format_decode (isa, insnbuf);
7215   if (fmt == XTENSA_UNDEFINED)
7216     return FALSE;
7217
7218   for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
7219     {
7220       xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
7221       opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
7222
7223       branch_seen = (branch_seen
7224                      || xtensa_opcode_is_branch (isa, opcode) == 1);
7225     }
7226
7227   if (!branch_seen)
7228     return FALSE;
7229
7230   offset += xtensa_format_length (isa, fmt);
7231   if (offset == next_fragP->fr_fix)
7232     {
7233       next_fragP = next_non_empty_frag (next_fragP);
7234       offset = 0;
7235     }
7236
7237   if (next_fragP == NULL)
7238     return FALSE;
7239
7240   /* Check for the retw/retw.n.  */
7241   xtensa_insnbuf_from_chars
7242     (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
7243   fmt = xtensa_format_decode (isa, insnbuf);
7244
7245   /* Because RETW[.N] is not bundleable, a VLIW bundle here means that we
7246      have no problems.  */
7247   if (fmt == XTENSA_UNDEFINED
7248       || xtensa_format_num_slots (isa, fmt) != 1)
7249     return FALSE;
7250
7251   xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7252   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7253
7254   if (opcode == xtensa_retw_opcode || opcode == xtensa_retw_n_opcode)
7255     return TRUE;
7256
7257   return FALSE;
7258 }
7259
7260
7261 /* Re-process all of the fragments looking to convert all of the
7262    RELAX_ADD_NOP_IF_PRE_LOOP_END.  If there is one instruction and a
7263    loop end label, convert this frag to one that will generate a NOP.
7264    In any case close it off with a .fill 0.  */
7265
7266 static bfd_boolean next_instr_is_loop_end (fragS *);
7267
7268 static void
7269 xtensa_fix_b_j_loop_end_frags (void)
7270 {
7271   frchainS *frchP;
7272
7273   /* When this routine is called, all of the subsections are still intact
7274      so we walk over subsections instead of sections.  */
7275   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7276     {
7277       fragS *fragP;
7278
7279       /* Walk over all of the fragments in a subsection.  */
7280       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7281         {
7282           if (fragP->fr_type == rs_machine_dependent
7283               && fragP->fr_subtype == RELAX_ADD_NOP_IF_PRE_LOOP_END)
7284             {
7285               if (next_instr_is_loop_end (fragP))
7286                 {
7287                   if (fragP->tc_frag_data.is_no_transform)
7288                     as_bad (_("branching or jumping to a loop end may trigger hardware errata"));
7289                   else
7290                     relax_frag_add_nop (fragP);
7291                 }
7292               frag_wane (fragP);
7293             }
7294         }
7295     }
7296 }
7297
7298
7299 static bfd_boolean
7300 next_instr_is_loop_end (fragS *fragP)
7301 {
7302   const fragS *next_fragP;
7303
7304   if (next_frag_is_loop_target (fragP))
7305     return FALSE;
7306
7307   next_fragP = next_non_empty_frag (fragP);
7308   if (next_fragP == NULL)
7309     return FALSE;
7310
7311   if (!next_frag_is_loop_target (next_fragP))
7312     return FALSE;
7313
7314   /* If the size is >= 3 then there is more than one instruction here.
7315      The hardware bug will not fire.  */
7316   if (next_fragP->fr_fix > 3)
7317     return FALSE;
7318
7319   return TRUE;
7320 }
7321
7322
7323 /* Re-process all of the fragments looking to convert all of the
7324    RELAX_ADD_NOP_IF_CLOSE_LOOP_END.  If there is an loop end that is
7325    not MY loop's loop end within 12 bytes, add enough nops here to
7326    make it at least 12 bytes away.  In any case close it off with a
7327    .fill 0.  */
7328
7329 static offsetT min_bytes_to_other_loop_end
7330   (fragS *, fragS *, offsetT, offsetT);
7331
7332 static void
7333 xtensa_fix_close_loop_end_frags (void)
7334 {
7335   frchainS *frchP;
7336
7337   /* When this routine is called, all of the subsections are still intact
7338      so we walk over subsections instead of sections.  */
7339   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7340     {
7341       fragS *fragP;
7342
7343       fragS *current_target = NULL;
7344       offsetT current_offset = 0;
7345
7346       /* Walk over all of the fragments in a subsection.  */
7347       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7348         {
7349           if (fragP->fr_type == rs_machine_dependent
7350               && ((fragP->fr_subtype == RELAX_IMMED)
7351                   || ((fragP->fr_subtype == RELAX_SLOTS)
7352                       && (fragP->tc_frag_data.slot_subtypes[0]
7353                           == RELAX_IMMED))))
7354             {
7355               /* Read it.  If the instruction is a loop, get the target.  */
7356               TInsn t_insn;
7357               tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7358               if (xtensa_opcode_is_loop (xtensa_default_isa,
7359                                          t_insn.opcode) == 1)
7360                 {
7361                   /* Get the current fragment target.  */
7362                   if (fragP->tc_frag_data.slot_symbols[0])
7363                     {
7364                       symbolS *sym = fragP->tc_frag_data.slot_symbols[0];
7365                       current_target = symbol_get_frag (sym);
7366                       current_offset = fragP->fr_offset;
7367                     }
7368                 }
7369             }
7370
7371           if (current_target
7372               && fragP->fr_type == rs_machine_dependent
7373               && fragP->fr_subtype == RELAX_ADD_NOP_IF_CLOSE_LOOP_END)
7374             {
7375               offsetT min_bytes;
7376               int bytes_added = 0;
7377
7378 #define REQUIRED_LOOP_DIVIDING_BYTES 12
7379               /* Max out at 12.  */
7380               min_bytes = min_bytes_to_other_loop_end
7381                 (fragP->fr_next, current_target, current_offset,
7382                  REQUIRED_LOOP_DIVIDING_BYTES);
7383
7384               if (min_bytes < REQUIRED_LOOP_DIVIDING_BYTES)
7385                 {
7386                   if (fragP->tc_frag_data.is_no_transform)
7387                     as_bad (_("loop end too close to another loop end may trigger hardware errata"));
7388                   else
7389                     {
7390                       while (min_bytes + bytes_added
7391                              < REQUIRED_LOOP_DIVIDING_BYTES)
7392                         {
7393                           int length = 3;
7394
7395                           if (fragP->fr_var < length)
7396                             as_fatal (_("fr_var %lu < length %d"),
7397                                       (long) fragP->fr_var, length);
7398                           else
7399                             {
7400                               assemble_nop (length,
7401                                             fragP->fr_literal + fragP->fr_fix);
7402                               fragP->fr_fix += length;
7403                               fragP->fr_var -= length;
7404                             }
7405                           bytes_added += length;
7406                         }
7407                     }
7408                 }
7409               frag_wane (fragP);
7410             }
7411           assert (fragP->fr_type != rs_machine_dependent
7412                   || fragP->fr_subtype != RELAX_ADD_NOP_IF_CLOSE_LOOP_END);
7413         }
7414     }
7415 }
7416
7417
7418 static offsetT unrelaxed_frag_min_size (fragS *);
7419
7420 static offsetT
7421 min_bytes_to_other_loop_end (fragS *fragP,
7422                              fragS *current_target,
7423                              offsetT current_offset,
7424                              offsetT max_size)
7425 {
7426   offsetT offset = 0;
7427   fragS *current_fragP;
7428
7429   for (current_fragP = fragP;
7430        current_fragP;
7431        current_fragP = current_fragP->fr_next)
7432     {
7433       if (current_fragP->tc_frag_data.is_loop_target
7434           && current_fragP != current_target)
7435         return offset + current_offset;
7436
7437       offset += unrelaxed_frag_min_size (current_fragP);
7438
7439       if (offset + current_offset >= max_size)
7440         return max_size;
7441     }
7442   return max_size;
7443 }
7444
7445
7446 static offsetT
7447 unrelaxed_frag_min_size (fragS *fragP)
7448 {
7449   offsetT size = fragP->fr_fix;
7450
7451   /* Add fill size.  */
7452   if (fragP->fr_type == rs_fill)
7453     size += fragP->fr_offset;
7454
7455   return size;
7456 }
7457
7458
7459 static offsetT
7460 unrelaxed_frag_max_size (fragS *fragP)
7461 {
7462   offsetT size = fragP->fr_fix;
7463   switch (fragP->fr_type)
7464     {
7465     case 0:
7466       /* Empty frags created by the obstack allocation scheme
7467          end up with type 0.  */
7468       break;
7469     case rs_fill:
7470     case rs_org:
7471     case rs_space:
7472       size += fragP->fr_offset;
7473       break;
7474     case rs_align:
7475     case rs_align_code:
7476     case rs_align_test:
7477     case rs_leb128:
7478     case rs_cfa:
7479     case rs_dwarf2dbg:
7480       /* No further adjustments needed.  */
7481       break;
7482     case rs_machine_dependent:
7483       if (fragP->fr_subtype != RELAX_DESIRE_ALIGN)
7484         size += fragP->fr_var;
7485       break;
7486     default:
7487       /* We had darn well better know how big it is.  */
7488       assert (0);
7489       break;
7490     }
7491
7492   return size;
7493 }
7494
7495
7496 /* Re-process all of the fragments looking to convert all
7497    of the RELAX_ADD_NOP_IF_SHORT_LOOP.  If:
7498
7499    A)
7500      1) the instruction size count to the loop end label
7501         is too short (<= 2 instructions),
7502      2) loop has a jump or branch in it
7503
7504    or B)
7505      1) workaround_all_short_loops is TRUE
7506      2) The generating loop was a  'loopgtz' or 'loopnez'
7507      3) the instruction size count to the loop end label is too short
7508         (<= 2 instructions)
7509    then convert this frag (and maybe the next one) to generate a NOP.
7510    In any case close it off with a .fill 0.  */
7511
7512 static int count_insns_to_loop_end (fragS *, bfd_boolean, int);
7513 static bfd_boolean branch_before_loop_end (fragS *);
7514
7515 static void
7516 xtensa_fix_short_loop_frags (void)
7517 {
7518   frchainS *frchP;
7519
7520   /* When this routine is called, all of the subsections are still intact
7521      so we walk over subsections instead of sections.  */
7522   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7523     {
7524       fragS *fragP;
7525       fragS *current_target = NULL;
7526       offsetT current_offset = 0;
7527       xtensa_opcode current_opcode = XTENSA_UNDEFINED;
7528
7529       /* Walk over all of the fragments in a subsection.  */
7530       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7531         {
7532           /* Check on the current loop.  */
7533           if (fragP->fr_type == rs_machine_dependent
7534               && ((fragP->fr_subtype == RELAX_IMMED)
7535                   || ((fragP->fr_subtype == RELAX_SLOTS)
7536                       && (fragP->tc_frag_data.slot_subtypes[0]
7537                           == RELAX_IMMED))))
7538             {
7539               TInsn t_insn;
7540
7541               /* Read it.  If the instruction is a loop, get the target.  */
7542               tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7543               if (xtensa_opcode_is_loop (xtensa_default_isa,
7544                                          t_insn.opcode) == 1)
7545                 {
7546                   /* Get the current fragment target.  */
7547                   if (fragP->tc_frag_data.slot_symbols[0])
7548                     {
7549                       symbolS *sym = fragP->tc_frag_data.slot_symbols[0];
7550                       current_target = symbol_get_frag (sym);
7551                       current_offset = fragP->fr_offset;
7552                       current_opcode = t_insn.opcode;
7553                     }
7554                 }
7555             }
7556
7557           if (fragP->fr_type == rs_machine_dependent
7558               && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP)
7559             {
7560               if (count_insns_to_loop_end (fragP->fr_next, TRUE, 3) < 3
7561                   && (branch_before_loop_end (fragP->fr_next)
7562                       || (workaround_all_short_loops
7563                           && current_opcode != XTENSA_UNDEFINED
7564                           && current_opcode != xtensa_loop_opcode)))
7565                 {
7566                   if (fragP->tc_frag_data.is_no_transform)
7567                     as_bad (_("loop containing less than three instructions may trigger hardware errata"));
7568                   else
7569                     relax_frag_add_nop (fragP);
7570                 }
7571               frag_wane (fragP);
7572             }
7573         }
7574     }
7575 }
7576
7577
7578 static int unrelaxed_frag_min_insn_count (fragS *);
7579
7580 static int
7581 count_insns_to_loop_end (fragS *base_fragP,
7582                          bfd_boolean count_relax_add,
7583                          int max_count)
7584 {
7585   fragS *fragP = NULL;
7586   int insn_count = 0;
7587
7588   fragP = base_fragP;
7589
7590   for (; fragP && !fragP->tc_frag_data.is_loop_target; fragP = fragP->fr_next)
7591     {
7592       insn_count += unrelaxed_frag_min_insn_count (fragP);
7593       if (insn_count >= max_count)
7594         return max_count;
7595
7596       if (count_relax_add)
7597         {
7598           if (fragP->fr_type == rs_machine_dependent
7599               && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP)
7600             {
7601               /* In order to add the appropriate number of
7602                  NOPs, we count an instruction for downstream
7603                  occurrences.  */
7604               insn_count++;
7605               if (insn_count >= max_count)
7606                 return max_count;
7607             }
7608         }
7609     }
7610   return insn_count;
7611 }
7612
7613
7614 static int
7615 unrelaxed_frag_min_insn_count (fragS *fragP)
7616 {
7617   xtensa_isa isa = xtensa_default_isa;
7618   static xtensa_insnbuf insnbuf = NULL;
7619   int insn_count = 0;
7620   int offset = 0;
7621
7622   if (!fragP->tc_frag_data.is_insn)
7623     return insn_count;
7624
7625   if (!insnbuf)
7626     insnbuf = xtensa_insnbuf_alloc (isa);
7627
7628   /* Decode the fixed instructions.  */
7629   while (offset < fragP->fr_fix)
7630     {
7631       xtensa_format fmt;
7632
7633       xtensa_insnbuf_from_chars
7634         (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
7635       fmt = xtensa_format_decode (isa, insnbuf);
7636
7637       if (fmt == XTENSA_UNDEFINED)
7638         {
7639           as_fatal (_("undecodable instruction in instruction frag"));
7640           return insn_count;
7641         }
7642       offset += xtensa_format_length (isa, fmt);
7643       insn_count++;
7644     }
7645
7646   return insn_count;
7647 }
7648
7649
7650 static bfd_boolean unrelaxed_frag_has_b_j (fragS *);
7651
7652 static bfd_boolean
7653 branch_before_loop_end (fragS *base_fragP)
7654 {
7655   fragS *fragP;
7656
7657   for (fragP = base_fragP;
7658        fragP && !fragP->tc_frag_data.is_loop_target;
7659        fragP = fragP->fr_next)
7660     {
7661       if (unrelaxed_frag_has_b_j (fragP))
7662         return TRUE;
7663     }
7664   return FALSE;
7665 }
7666
7667
7668 static bfd_boolean
7669 unrelaxed_frag_has_b_j (fragS *fragP)
7670 {
7671   static xtensa_insnbuf insnbuf = NULL;
7672   xtensa_isa isa = xtensa_default_isa;
7673   int offset = 0;
7674
7675   if (!fragP->tc_frag_data.is_insn)
7676     return FALSE;
7677
7678   if (!insnbuf)
7679     insnbuf = xtensa_insnbuf_alloc (isa);
7680
7681   /* Decode the fixed instructions.  */
7682   while (offset < fragP->fr_fix)
7683     {
7684       xtensa_format fmt;
7685       int slot;
7686
7687       xtensa_insnbuf_from_chars
7688         (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
7689       fmt = xtensa_format_decode (isa, insnbuf);
7690       if (fmt == XTENSA_UNDEFINED)
7691         return FALSE;
7692
7693       for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
7694         {
7695           xtensa_opcode opcode =
7696             get_opcode_from_buf (fragP->fr_literal + offset, slot);
7697           if (xtensa_opcode_is_branch (isa, opcode) == 1
7698               || xtensa_opcode_is_jump (isa, opcode) == 1)
7699             return TRUE;
7700         }
7701       offset += xtensa_format_length (isa, fmt);
7702     }
7703   return FALSE;
7704 }
7705
7706
7707 /* Checks to be made after initial assembly but before relaxation.  */
7708
7709 static bfd_boolean is_empty_loop (const TInsn *, fragS *);
7710 static bfd_boolean is_local_forward_loop (const TInsn *, fragS *);
7711
7712 static void
7713 xtensa_sanity_check (void)
7714 {
7715   char *file_name;
7716   unsigned line;
7717
7718   frchainS *frchP;
7719
7720   as_where (&file_name, &line);
7721   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7722     {
7723       fragS *fragP;
7724
7725       /* Walk over all of the fragments in a subsection.  */
7726       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7727         {
7728           /* Currently we only check for empty loops here.  */
7729           if (fragP->fr_type == rs_machine_dependent
7730               && fragP->fr_subtype == RELAX_IMMED)
7731             {
7732               static xtensa_insnbuf insnbuf = NULL;
7733               TInsn t_insn;
7734
7735               if (fragP->fr_opcode != NULL)
7736                 {
7737                   if (!insnbuf)
7738                     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
7739                   tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7740                   tinsn_immed_from_frag (&t_insn, fragP, 0);
7741
7742                   if (xtensa_opcode_is_loop (xtensa_default_isa,
7743                                              t_insn.opcode) == 1)
7744                     {
7745                       if (is_empty_loop (&t_insn, fragP))
7746                         {
7747                           new_logical_line (fragP->fr_file, fragP->fr_line);
7748                           as_bad (_("invalid empty loop"));
7749                         }
7750                       if (!is_local_forward_loop (&t_insn, fragP))
7751                         {
7752                           new_logical_line (fragP->fr_file, fragP->fr_line);
7753                           as_bad (_("loop target does not follow "
7754                                     "loop instruction in section"));
7755                         }
7756                     }
7757                 }
7758             }
7759         }
7760     }
7761   new_logical_line (file_name, line);
7762 }
7763
7764
7765 #define LOOP_IMMED_OPN 1
7766
7767 /* Return TRUE if the loop target is the next non-zero fragment.  */
7768
7769 static bfd_boolean
7770 is_empty_loop (const TInsn *insn, fragS *fragP)
7771 {
7772   const expressionS *expr;
7773   symbolS *symbolP;
7774   fragS *next_fragP;
7775
7776   if (insn->insn_type != ITYPE_INSN)
7777     return FALSE;
7778
7779   if (xtensa_opcode_is_loop (xtensa_default_isa, insn->opcode) != 1)
7780     return FALSE;
7781
7782   if (insn->ntok <= LOOP_IMMED_OPN)
7783     return FALSE;
7784
7785   expr = &insn->tok[LOOP_IMMED_OPN];
7786
7787   if (expr->X_op != O_symbol)
7788     return FALSE;
7789
7790   symbolP = expr->X_add_symbol;
7791   if (!symbolP)
7792     return FALSE;
7793
7794   if (symbol_get_frag (symbolP) == NULL)
7795     return FALSE;
7796
7797   if (S_GET_VALUE (symbolP) != 0)
7798     return FALSE;
7799
7800   /* Walk through the zero-size fragments from this one.  If we find
7801      the target fragment, then this is a zero-size loop.  */
7802
7803   for (next_fragP = fragP->fr_next;
7804        next_fragP != NULL;
7805        next_fragP = next_fragP->fr_next)
7806     {
7807       if (next_fragP == symbol_get_frag (symbolP))
7808         return TRUE;
7809       if (next_fragP->fr_fix != 0)
7810         return FALSE;
7811     }
7812   return FALSE;
7813 }
7814
7815
7816 static bfd_boolean
7817 is_local_forward_loop (const TInsn *insn, fragS *fragP)
7818 {
7819   const expressionS *expr;
7820   symbolS *symbolP;
7821   fragS *next_fragP;
7822
7823   if (insn->insn_type != ITYPE_INSN)
7824     return FALSE;
7825
7826   if (xtensa_opcode_is_loop (xtensa_default_isa, insn->opcode) == 0)
7827     return FALSE;
7828
7829   if (insn->ntok <= LOOP_IMMED_OPN)
7830     return FALSE;
7831
7832   expr = &insn->tok[LOOP_IMMED_OPN];
7833
7834   if (expr->X_op != O_symbol)
7835     return FALSE;
7836
7837   symbolP = expr->X_add_symbol;
7838   if (!symbolP)
7839     return FALSE;
7840
7841   if (symbol_get_frag (symbolP) == NULL)
7842     return FALSE;
7843
7844   /* Walk through fragments until we find the target.
7845      If we do not find the target, then this is an invalid loop.  */
7846
7847   for (next_fragP = fragP->fr_next;
7848        next_fragP != NULL;
7849        next_fragP = next_fragP->fr_next)
7850     {
7851       if (next_fragP == symbol_get_frag (symbolP))
7852         return TRUE;
7853     }
7854
7855   return FALSE;
7856 }
7857
7858 \f
7859 /* Alignment Functions.  */
7860
7861 static int
7862 get_text_align_power (unsigned target_size)
7863 {
7864   int i = 0;
7865   unsigned power = 1;
7866
7867   assert (target_size <= INT_MAX);
7868   while (target_size > power)
7869     {
7870       power <<= 1;
7871       i += 1;
7872     }
7873   return i;
7874 }
7875
7876
7877 static int
7878 get_text_align_max_fill_size (int align_pow,
7879                               bfd_boolean use_nops,
7880                               bfd_boolean use_no_density)
7881 {
7882   if (!use_nops)
7883     return (1 << align_pow);
7884   if (use_no_density)
7885     return 3 * (1 << align_pow);
7886
7887   return 1 + (1 << align_pow);
7888 }
7889
7890
7891 /* Calculate the minimum bytes of fill needed at "address" to align a
7892    target instruction of size "target_size" so that it does not cross a
7893    power-of-two boundary specified by "align_pow".  If "use_nops" is FALSE,
7894    the fill can be an arbitrary number of bytes.  Otherwise, the space must
7895    be filled by NOP instructions.  */
7896
7897 static int
7898 get_text_align_fill_size (addressT address,
7899                           int align_pow,
7900                           int target_size,
7901                           bfd_boolean use_nops,
7902                           bfd_boolean use_no_density)
7903 {
7904   addressT alignment, fill, fill_limit, fill_step;
7905   bfd_boolean skip_one = FALSE;
7906
7907   alignment = (1 << align_pow);
7908   assert (target_size > 0 && alignment >= (addressT) target_size);
7909
7910   if (!use_nops)
7911     {
7912       fill_limit = alignment;
7913       fill_step = 1;
7914     }
7915   else if (!use_no_density)
7916     {
7917       /* Combine 2- and 3-byte NOPs to fill anything larger than one.  */
7918       fill_limit = alignment * 2;
7919       fill_step = 1;
7920       skip_one = TRUE;
7921     }
7922   else
7923     {
7924       /* Fill with 3-byte NOPs -- can only fill multiples of 3.  */
7925       fill_limit = alignment * 3;
7926       fill_step = 3;
7927     }
7928
7929   /* Try all fill sizes until finding one that works.  */
7930   for (fill = 0; fill < fill_limit; fill += fill_step)
7931     {
7932       if (skip_one && fill == 1)
7933         continue;
7934       if ((address + fill) >> align_pow
7935           == (address + fill + target_size - 1) >> align_pow)
7936         return fill;
7937     }
7938   assert (0);
7939   return 0;
7940 }
7941
7942
7943 static int
7944 branch_align_power (segT sec)
7945 {
7946   /* If the Xtensa processor has a fetch width of 8 bytes, and the section
7947      is aligned to at least an 8-byte boundary, then a branch target need
7948      only fit within an 8-byte aligned block of memory to avoid a stall.
7949      Otherwise, try to fit branch targets within 4-byte aligned blocks
7950      (which may be insufficient, e.g., if the section has no alignment, but
7951      it's good enough).  */
7952   if (xtensa_fetch_width == 8)
7953     {
7954       if (get_recorded_alignment (sec) >= 3)
7955         return 3;
7956     }
7957   else
7958     assert (xtensa_fetch_width == 4);
7959
7960   return 2;
7961 }
7962
7963
7964 /* This will assert if it is not possible.  */
7965
7966 static int
7967 get_text_align_nop_count (offsetT fill_size, bfd_boolean use_no_density)
7968 {
7969   int count = 0;
7970
7971   if (use_no_density)
7972     {
7973       assert (fill_size % 3 == 0);
7974       return (fill_size / 3);
7975     }
7976
7977   assert (fill_size != 1);      /* Bad argument.  */
7978
7979   while (fill_size > 1)
7980     {
7981       int insn_size = 3;
7982       if (fill_size == 2 || fill_size == 4)
7983         insn_size = 2;
7984       fill_size -= insn_size;
7985       count++;
7986     }
7987   assert (fill_size != 1);      /* Bad algorithm.  */
7988   return count;
7989 }
7990
7991
7992 static int
7993 get_text_align_nth_nop_size (offsetT fill_size,
7994                              int n,
7995                              bfd_boolean use_no_density)
7996 {
7997   int count = 0;
7998
7999   if (use_no_density)
8000     return 3;
8001
8002   assert (fill_size != 1);      /* Bad argument.  */
8003
8004   while (fill_size > 1)
8005     {
8006       int insn_size = 3;
8007       if (fill_size == 2 || fill_size == 4)
8008         insn_size = 2;
8009       fill_size -= insn_size;
8010       count++;
8011       if (n + 1 == count)
8012         return insn_size;
8013     }
8014   assert (0);
8015   return 0;
8016 }
8017
8018
8019 /* For the given fragment, find the appropriate address
8020    for it to begin at if we are using NOPs to align it.  */
8021
8022 static addressT
8023 get_noop_aligned_address (fragS *fragP, addressT address)
8024 {
8025   /* The rule is: get next fragment's FIRST instruction.  Find
8026      the smallest number of bytes that need to be added to
8027      ensure that the next fragment's FIRST instruction will fit
8028      in a single word.
8029
8030      E.G.,   2 bytes : 0, 1, 2 mod 4
8031              3 bytes: 0, 1 mod 4
8032
8033      If the FIRST instruction MIGHT be relaxed,
8034      assume that it will become a 3-byte instruction.
8035
8036      Note again here that LOOP instructions are not bundleable,
8037      and this relaxation only applies to LOOP opcodes.  */
8038
8039   int fill_size = 0;
8040   int first_insn_size;
8041   int loop_insn_size;
8042   addressT pre_opcode_bytes;
8043   int align_power;
8044   fragS *first_insn;
8045   xtensa_opcode opcode;
8046   bfd_boolean is_loop;
8047
8048   assert (fragP->fr_type == rs_machine_dependent);
8049   assert (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE);
8050
8051   /* Find the loop frag.  */
8052   first_insn = next_non_empty_frag (fragP);
8053   /* Now find the first insn frag.  */
8054   first_insn = next_non_empty_frag (first_insn);
8055
8056   is_loop = next_frag_opcode_is_loop (fragP, &opcode);
8057   assert (is_loop);
8058   loop_insn_size = xg_get_single_size (opcode);
8059
8060   pre_opcode_bytes = next_frag_pre_opcode_bytes (fragP);
8061   pre_opcode_bytes += loop_insn_size;
8062
8063   /* For loops, the alignment depends on the size of the
8064      instruction following the loop, not the LOOP instruction.  */
8065
8066   if (first_insn == NULL)
8067     return address;
8068
8069   assert (first_insn->tc_frag_data.is_first_loop_insn);
8070
8071   first_insn_size = frag_format_size (first_insn);
8072
8073   if (first_insn_size == 2 || first_insn_size == XTENSA_UNDEFINED)
8074     first_insn_size = 3;        /* ISA specifies this */
8075
8076   /* If it was 8, then we'll need a larger alignment for the section.  */
8077   align_power = get_text_align_power (first_insn_size);
8078   record_alignment (now_seg, align_power);
8079
8080   fill_size = get_text_align_fill_size
8081     (address + pre_opcode_bytes, align_power, first_insn_size, TRUE,
8082      fragP->tc_frag_data.is_no_density);
8083
8084   return address + fill_size;
8085 }
8086
8087
8088 /* 3 mechanisms for relaxing an alignment:
8089
8090    Align to a power of 2.
8091    Align so the next fragment's instruction does not cross a word boundary.
8092    Align the current instruction so that if the next instruction
8093        were 3 bytes, it would not cross a word boundary.
8094
8095    We can align with:
8096
8097    zeros    - This is easy; always insert zeros.
8098    nops     - 3-byte and 2-byte instructions
8099               2 - 2-byte nop
8100               3 - 3-byte nop
8101               4 - 2 2-byte nops
8102               >=5 : 3-byte instruction + fn (n-3)
8103    widening - widen previous instructions.  */
8104
8105 static offsetT
8106 get_aligned_diff (fragS *fragP, addressT address, offsetT *max_diff)
8107 {
8108   addressT target_address, loop_insn_offset;
8109   int target_size;
8110   xtensa_opcode loop_opcode;
8111   bfd_boolean is_loop;
8112   int align_power;
8113   offsetT opt_diff;
8114   offsetT branch_align;
8115
8116   assert (fragP->fr_type == rs_machine_dependent);
8117   switch (fragP->fr_subtype)
8118     {
8119     case RELAX_DESIRE_ALIGN:
8120       target_size = next_frag_format_size (fragP);
8121       if (target_size == XTENSA_UNDEFINED)
8122         target_size = 3;
8123       align_power = branch_align_power (now_seg);
8124       branch_align = 1 << align_power;
8125       /* Don't count on the section alignment being as large as the target.  */
8126       if (target_size > branch_align)
8127         target_size = branch_align;
8128       opt_diff = get_text_align_fill_size (address, align_power,
8129                                            target_size, FALSE, FALSE);
8130
8131       *max_diff = (opt_diff + branch_align
8132                    - (target_size + ((address + opt_diff) % branch_align)));
8133       assert (*max_diff >= opt_diff);
8134       return opt_diff;
8135
8136     case RELAX_ALIGN_NEXT_OPCODE:
8137       target_size = next_frag_format_size (fragP);
8138       loop_insn_offset = 0;
8139       is_loop = next_frag_opcode_is_loop (fragP, &loop_opcode);
8140       assert (is_loop);
8141
8142       /* If the loop has been expanded then the LOOP instruction
8143          could be at an offset from this fragment.  */
8144       if (next_non_empty_frag(fragP)->tc_frag_data.slot_subtypes[0]
8145           != RELAX_IMMED)
8146         loop_insn_offset = get_expanded_loop_offset (loop_opcode);
8147
8148       if (target_size == 2)
8149         target_size = 3; /* ISA specifies this */
8150
8151       /* In an ideal world, which is what we are shooting for here,
8152          we wouldn't need to use any NOPs immediately prior to the
8153          LOOP instruction.  If this approach fails, relax_frag_loop_align
8154          will call get_noop_aligned_address.  */
8155       target_address =
8156         address + loop_insn_offset + xg_get_single_size (loop_opcode);
8157       align_power = get_text_align_power (target_size),
8158       opt_diff = get_text_align_fill_size (target_address, align_power,
8159                                            target_size, FALSE, FALSE);
8160
8161       *max_diff = xtensa_fetch_width
8162         - ((target_address + opt_diff) % xtensa_fetch_width)
8163         - target_size + opt_diff;
8164       assert (*max_diff >= opt_diff);
8165       return opt_diff;
8166
8167     default:
8168       break;
8169     }
8170   assert (0);
8171   return 0;
8172 }
8173
8174 \f
8175 /* md_relax_frag Hook and Helper Functions.  */
8176
8177 static long relax_frag_loop_align (fragS *, long);
8178 static long relax_frag_for_align (fragS *, long);
8179 static long relax_frag_immed
8180   (segT, fragS *, long, int, xtensa_format, int, int *, bfd_boolean);
8181
8182
8183 /* Return the number of bytes added to this fragment, given that the
8184    input has been stretched already by "stretch".  */
8185
8186 long
8187 xtensa_relax_frag (fragS *fragP, long stretch, int *stretched_p)
8188 {
8189   xtensa_isa isa = xtensa_default_isa;
8190   int unreported = fragP->tc_frag_data.unreported_expansion;
8191   long new_stretch = 0;
8192   char *file_name;
8193   unsigned line;
8194   int lit_size;
8195   static xtensa_insnbuf vbuf = NULL;
8196   int slot, num_slots;
8197   xtensa_format fmt;
8198
8199   as_where (&file_name, &line);
8200   new_logical_line (fragP->fr_file, fragP->fr_line);
8201
8202   fragP->tc_frag_data.unreported_expansion = 0;
8203
8204   switch (fragP->fr_subtype)
8205     {
8206     case RELAX_ALIGN_NEXT_OPCODE:
8207       /* Always convert.  */
8208       if (fragP->tc_frag_data.relax_seen)
8209         new_stretch = relax_frag_loop_align (fragP, stretch);
8210       break;
8211
8212     case RELAX_LOOP_END:
8213       /* Do nothing.  */
8214       break;
8215
8216     case RELAX_LOOP_END_ADD_NOP:
8217       /* Add a NOP and switch to .fill 0.  */
8218       new_stretch = relax_frag_add_nop (fragP);
8219       frag_wane (fragP);
8220       break;
8221
8222     case RELAX_DESIRE_ALIGN:
8223       /* Do nothing. The narrowing before this frag will either align
8224          it or not.  */
8225       break;
8226
8227     case RELAX_LITERAL:
8228     case RELAX_LITERAL_FINAL:
8229       return 0;
8230
8231     case RELAX_LITERAL_NR:
8232       lit_size = 4;
8233       fragP->fr_subtype = RELAX_LITERAL_FINAL;
8234       assert (unreported == lit_size);
8235       memset (&fragP->fr_literal[fragP->fr_fix], 0, 4);
8236       fragP->fr_var -= lit_size;
8237       fragP->fr_fix += lit_size;
8238       new_stretch = 4;
8239       break;
8240
8241     case RELAX_SLOTS:
8242       if (vbuf == NULL)
8243         vbuf = xtensa_insnbuf_alloc (isa);
8244
8245       xtensa_insnbuf_from_chars
8246         (isa, vbuf, (unsigned char *) fragP->fr_opcode, 0);
8247       fmt = xtensa_format_decode (isa, vbuf);
8248       num_slots = xtensa_format_num_slots (isa, fmt);
8249
8250       for (slot = 0; slot < num_slots; slot++)
8251         {
8252           switch (fragP->tc_frag_data.slot_subtypes[slot])
8253             {
8254             case RELAX_NARROW:
8255               if (fragP->tc_frag_data.relax_seen)
8256                 new_stretch += relax_frag_for_align (fragP, stretch);
8257               break;
8258
8259             case RELAX_IMMED:
8260             case RELAX_IMMED_STEP1:
8261             case RELAX_IMMED_STEP2:
8262               /* Place the immediate.  */
8263               new_stretch += relax_frag_immed
8264                 (now_seg, fragP, stretch,
8265                  fragP->tc_frag_data.slot_subtypes[slot] - RELAX_IMMED,
8266                  fmt, slot, stretched_p, FALSE);
8267               break;
8268
8269             default:
8270               /* This is OK; see the note in xg_assemble_vliw_tokens.  */
8271               break;
8272             }
8273         }
8274       break;
8275
8276     case RELAX_LITERAL_POOL_BEGIN:
8277     case RELAX_LITERAL_POOL_END:
8278     case RELAX_MAYBE_UNREACHABLE:
8279     case RELAX_MAYBE_DESIRE_ALIGN:
8280       /* No relaxation required.  */
8281       break;
8282
8283     case RELAX_FILL_NOP:
8284     case RELAX_UNREACHABLE:
8285       if (fragP->tc_frag_data.relax_seen)
8286         new_stretch += relax_frag_for_align (fragP, stretch);
8287       break;
8288
8289     default:
8290       as_bad (_("bad relaxation state"));
8291     }
8292
8293   /* Tell gas we need another relaxation pass.  */
8294   if (! fragP->tc_frag_data.relax_seen)
8295     {
8296       fragP->tc_frag_data.relax_seen = TRUE;
8297       *stretched_p = 1;
8298     }
8299
8300   new_logical_line (file_name, line);
8301   return new_stretch;
8302 }
8303
8304
8305 static long
8306 relax_frag_loop_align (fragS *fragP, long stretch)
8307 {
8308   addressT old_address, old_next_address, old_size;
8309   addressT new_address, new_next_address, new_size;
8310   addressT growth;
8311
8312   /* All the frags with relax_frag_for_alignment prior to this one in the
8313      section have been done, hopefully eliminating the need for a NOP here.
8314      But, this will put it in if necessary.  */
8315
8316   /* Calculate the old address of this fragment and the next fragment.  */
8317   old_address = fragP->fr_address - stretch;
8318   old_next_address = (fragP->fr_address - stretch + fragP->fr_fix +
8319                       fragP->tc_frag_data.text_expansion[0]);
8320   old_size = old_next_address - old_address;
8321
8322   /* Calculate the new address of this fragment and the next fragment.  */
8323   new_address = fragP->fr_address;
8324   new_next_address =
8325     get_noop_aligned_address (fragP, fragP->fr_address + fragP->fr_fix);
8326   new_size = new_next_address - new_address;
8327
8328   growth = new_size - old_size;
8329
8330   /* Fix up the text_expansion field and return the new growth.  */
8331   fragP->tc_frag_data.text_expansion[0] += growth;
8332   return growth;
8333 }
8334
8335
8336 /* Add a NOP instruction.  */
8337
8338 static long
8339 relax_frag_add_nop (fragS *fragP)
8340 {
8341   char *nop_buf = fragP->fr_literal + fragP->fr_fix;
8342   int length = fragP->tc_frag_data.is_no_density ? 3 : 2;
8343   assemble_nop (length, nop_buf);
8344   fragP->tc_frag_data.is_insn = TRUE;
8345
8346   if (fragP->fr_var < length)
8347     {
8348       as_fatal (_("fr_var (%ld) < length (%d)"), (long) fragP->fr_var, length);
8349       return 0;
8350     }
8351
8352   fragP->fr_fix += length;
8353   fragP->fr_var -= length;
8354   return length;
8355 }
8356
8357
8358 static long future_alignment_required (fragS *, long);
8359
8360 static long
8361 relax_frag_for_align (fragS *fragP, long stretch)
8362 {
8363   /* Overview of the relaxation procedure for alignment:
8364      We can widen with NOPs or by widening instructions or by filling
8365      bytes after jump instructions.  Find the opportune places and widen
8366      them if necessary.  */
8367
8368   long stretch_me;
8369   long diff;
8370
8371   assert (fragP->fr_subtype == RELAX_FILL_NOP
8372           || fragP->fr_subtype == RELAX_UNREACHABLE
8373           || (fragP->fr_subtype == RELAX_SLOTS
8374               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW));
8375
8376   stretch_me = future_alignment_required (fragP, stretch);
8377   diff = stretch_me - fragP->tc_frag_data.text_expansion[0];
8378   if (diff == 0)
8379     return 0;
8380
8381   if (diff < 0)
8382     {
8383       /* We expanded on a previous pass.  Can we shrink now?  */
8384       long shrink = fragP->tc_frag_data.text_expansion[0] - stretch_me;
8385       if (shrink <= stretch && stretch > 0)
8386         {
8387           fragP->tc_frag_data.text_expansion[0] = stretch_me;
8388           return -shrink;
8389         }
8390       return 0;
8391     }
8392
8393   /* Below here, diff > 0.  */
8394   fragP->tc_frag_data.text_expansion[0] = stretch_me;
8395
8396   return diff;
8397 }
8398
8399
8400 /* Return the address of the next frag that should be aligned.
8401
8402    By "address" we mean the address it _would_ be at if there
8403    is no action taken to align it between here and the target frag.
8404    In other words, if no narrows and no fill nops are used between
8405    here and the frag to align, _even_if_ some of the frags we use
8406    to align targets have already expanded on a previous relaxation
8407    pass.
8408
8409    Also, count each frag that may be used to help align the target.
8410
8411    Return 0 if there are no frags left in the chain that need to be
8412    aligned.  */
8413
8414 static addressT
8415 find_address_of_next_align_frag (fragS **fragPP,
8416                                  int *wide_nops,
8417                                  int *narrow_nops,
8418                                  int *widens,
8419                                  bfd_boolean *paddable)
8420 {
8421   fragS *fragP = *fragPP;
8422   addressT address = fragP->fr_address;
8423
8424   /* Do not reset the counts to 0.  */
8425
8426   while (fragP)
8427     {
8428       /* Limit this to a small search.  */
8429       if (*widens > 8)
8430         {
8431           *fragPP = fragP;
8432           return 0;
8433         }
8434       address += fragP->fr_fix;
8435
8436       if (fragP->fr_type == rs_fill)
8437         address += fragP->fr_offset * fragP->fr_var;
8438       else if (fragP->fr_type == rs_machine_dependent)
8439         {
8440           switch (fragP->fr_subtype)
8441             {
8442             case RELAX_UNREACHABLE:
8443               *paddable = TRUE;
8444               break;
8445
8446             case RELAX_FILL_NOP:
8447               (*wide_nops)++;
8448               if (!fragP->tc_frag_data.is_no_density)
8449                 (*narrow_nops)++;
8450               break;
8451
8452             case RELAX_SLOTS:
8453               if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
8454                 {
8455                   (*widens)++;
8456                   break;
8457                 }
8458               address += total_frag_text_expansion (fragP);;
8459               break;
8460
8461             case RELAX_IMMED:
8462               address += fragP->tc_frag_data.text_expansion[0];
8463               break;
8464
8465             case RELAX_ALIGN_NEXT_OPCODE:
8466             case RELAX_DESIRE_ALIGN:
8467               *fragPP = fragP;
8468               return address;
8469
8470             case RELAX_MAYBE_UNREACHABLE:
8471             case RELAX_MAYBE_DESIRE_ALIGN:
8472               /* Do nothing.  */
8473               break;
8474
8475             default:
8476               /* Just punt if we don't know the type.  */
8477               *fragPP = fragP;
8478               return 0;
8479             }
8480         }
8481       else
8482         {
8483           /* Just punt if we don't know the type.  */
8484           *fragPP = fragP;
8485           return 0;
8486         }
8487       fragP = fragP->fr_next;
8488     }
8489
8490   *fragPP = fragP;
8491   return 0;
8492 }
8493
8494
8495 static long bytes_to_stretch (fragS *, int, int, int, int);
8496
8497 static long
8498 future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
8499 {
8500   fragS *this_frag = fragP;
8501   long address;
8502   int num_widens = 0;
8503   int wide_nops = 0;
8504   int narrow_nops = 0;
8505   bfd_boolean paddable = FALSE;
8506   offsetT local_opt_diff;
8507   offsetT opt_diff;
8508   offsetT max_diff;
8509   int stretch_amount = 0;
8510   int local_stretch_amount;
8511   int global_stretch_amount;
8512
8513   address = find_address_of_next_align_frag
8514     (&fragP, &wide_nops, &narrow_nops, &num_widens, &paddable);
8515
8516   if (address)
8517     {
8518       local_opt_diff = get_aligned_diff (fragP, address, &max_diff);
8519       opt_diff = local_opt_diff;
8520       assert (opt_diff >= 0);
8521       assert (max_diff >= opt_diff);
8522       if (max_diff == 0)
8523         return 0;
8524
8525       if (fragP)
8526         fragP = fragP->fr_next;
8527
8528       while (fragP && opt_diff < max_diff && address)
8529         {
8530           /* We only use these to determine if we can exit early
8531              because there will be plenty of ways to align future
8532              align frags.  */
8533           int glob_widens = 0;
8534           int dnn = 0;
8535           int dw = 0;
8536           bfd_boolean glob_pad = 0;
8537           address = find_address_of_next_align_frag
8538             (&fragP, &glob_widens, &dnn, &dw, &glob_pad);
8539           /* If there is a padable portion, then skip.  */
8540           if (glob_pad || glob_widens >= (1 << branch_align_power (now_seg)))
8541             break;
8542
8543           if (address)
8544             {
8545               offsetT next_m_diff;
8546               offsetT next_o_diff;
8547
8548               /* Downrange frags haven't had stretch added to them yet.  */
8549               address += stretch;
8550
8551               /* The address also includes any text expansion from this
8552                  frag in a previous pass, but we don't want that.  */
8553               address -= this_frag->tc_frag_data.text_expansion[0];
8554
8555               /* Assume we are going to move at least opt_diff.  In
8556                  reality, we might not be able to, but assuming that
8557                  we will helps catch cases where moving opt_diff pushes
8558                  the next target from aligned to unaligned.  */
8559               address += opt_diff;
8560
8561               next_o_diff = get_aligned_diff (fragP, address, &next_m_diff);
8562
8563               /* Now cleanup for the adjustments to address.  */
8564               next_o_diff += opt_diff;
8565               next_m_diff += opt_diff;
8566               if (next_o_diff <= max_diff && next_o_diff > opt_diff)
8567                 opt_diff = next_o_diff;
8568               if (next_m_diff < max_diff)
8569                 max_diff = next_m_diff;
8570               fragP = fragP->fr_next;
8571             }
8572         }
8573
8574       /* If there are enough wideners in between, do it.  */
8575       if (paddable)
8576         {
8577           if (this_frag->fr_subtype == RELAX_UNREACHABLE)
8578             {
8579               assert (opt_diff <= UNREACHABLE_MAX_WIDTH);
8580               return opt_diff;
8581             }
8582           return 0;
8583         }
8584       local_stretch_amount
8585         = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
8586                             num_widens, local_opt_diff);
8587       global_stretch_amount
8588         = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
8589                             num_widens, opt_diff);
8590       /* If the condition below is true, then the frag couldn't
8591          stretch the correct amount for the global case, so we just
8592          optimize locally.  We'll rely on the subsequent frags to get
8593          the correct alignment in the global case.  */
8594       if (global_stretch_amount < local_stretch_amount)
8595         stretch_amount = local_stretch_amount;
8596       else
8597         stretch_amount = global_stretch_amount;
8598
8599       if (this_frag->fr_subtype == RELAX_SLOTS
8600           && this_frag->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
8601         assert (stretch_amount <= 1);
8602       else if (this_frag->fr_subtype == RELAX_FILL_NOP)
8603         {
8604           if (this_frag->tc_frag_data.is_no_density)
8605             assert (stretch_amount == 3 || stretch_amount == 0);
8606           else
8607             assert (stretch_amount <= 3);
8608         }
8609     }
8610   return stretch_amount;
8611 }
8612
8613
8614 /* The idea: widen everything you can to get a target or loop aligned,
8615    then start using NOPs.
8616
8617    When we must have a NOP, here is a table of how we decide
8618    (so you don't have to fight through the control flow below):
8619
8620    wide_nops   = the number of wide NOPs available for aligning
8621    narrow_nops = the number of narrow NOPs available for aligning
8622                  (a subset of wide_nops)
8623    widens      = the number of narrow instructions that should be widened
8624
8625    Desired   wide   narrow
8626    Diff      nop    nop      widens
8627    1           0      0         1
8628    2           0      1         0
8629    3a          1      0         0
8630     b          0      1         1 (case 3a makes this case unnecessary)
8631    4a          1      0         1
8632     b          0      2         0
8633     c          0      1         2 (case 4a makes this case unnecessary)
8634    5a          1      0         2
8635     b          1      1         0
8636     c          0      2         1 (case 5b makes this case unnecessary)
8637    6a          2      0         0
8638     b          1      0         3
8639     c          0      1         4 (case 6b makes this case unneccesary)
8640     d          1      1         1 (case 6a makes this case unnecessary)
8641     e          0      2         2 (case 6a makes this case unnecessary)
8642     f          0      3         0 (case 6a makes this case unnecessary)
8643    7a          1      0         4
8644     b          2      0         1
8645     c          1      1         2 (case 7b makes this case unnecessary)
8646     d          0      1         5 (case 7a makes this case unnecessary)
8647     e          0      2         3 (case 7b makes this case unnecessary)
8648     f          0      3         1 (case 7b makes this case unnecessary)
8649     g          1      2         1 (case 7b makes this case unnecessary)
8650 */
8651
8652 static long
8653 bytes_to_stretch (fragS *this_frag,
8654                   int wide_nops,
8655                   int narrow_nops,
8656                   int num_widens,
8657                   int desired_diff)
8658 {
8659   int bytes_short = desired_diff - num_widens;
8660
8661   assert (desired_diff >= 0 && desired_diff < 8);
8662   if (desired_diff == 0)
8663     return 0;
8664
8665   assert (wide_nops > 0 || num_widens > 0);
8666
8667   /* Always prefer widening to NOP-filling.  */
8668   if (bytes_short < 0)
8669     {
8670       /* There are enough RELAX_NARROW frags after this one
8671          to align the target without widening this frag in any way.  */
8672       return 0;
8673     }
8674
8675   if (bytes_short == 0)
8676     {
8677       /* Widen every narrow between here and the align target
8678          and the align target will be properly aligned.  */
8679       if (this_frag->fr_subtype == RELAX_FILL_NOP)
8680         return 0;
8681       else
8682         return 1;
8683     }
8684
8685   /* From here we will need at least one NOP to get an alignment.
8686      However, we may not be able to align at all, in which case,
8687      don't widen.  */
8688   if (this_frag->fr_subtype == RELAX_FILL_NOP)
8689     {
8690       switch (desired_diff)
8691         {
8692         case 1:
8693           return 0;
8694         case 2:
8695           if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 1)
8696             return 2; /* case 2 */
8697           return 0;
8698         case 3:
8699           if (wide_nops > 1)
8700             return 0;
8701           else
8702             return 3; /* case 3a */
8703         case 4:
8704           if (num_widens >= 1 && wide_nops == 1)
8705             return 3; /* case 4a */
8706           if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 2)
8707             return 2; /* case 4b */
8708           return 0;
8709         case 5:
8710           if (num_widens >= 2 && wide_nops == 1)
8711             return 3; /* case 5a */
8712           /* We will need two nops.  Are there enough nops
8713              between here and the align target?  */
8714           if (wide_nops < 2 || narrow_nops == 0)
8715             return 0;
8716           /* Are there other nops closer that can serve instead?  */
8717           if (wide_nops > 2 && narrow_nops > 1)
8718             return 0;
8719           /* Take the density one first, because there might not be
8720              another density one available.  */
8721           if (!this_frag->tc_frag_data.is_no_density)
8722             return 2; /* case 5b narrow */
8723           else
8724             return 3; /* case 5b wide */
8725           return 0;
8726         case 6:
8727           if (wide_nops == 2)
8728             return 3; /* case 6a */
8729           else if (num_widens >= 3 && wide_nops == 1)
8730             return 3; /* case 6b */
8731           return 0;
8732         case 7:
8733           if (wide_nops == 1 && num_widens >= 4)
8734             return 3; /* case 7a */
8735           else if (wide_nops == 2 && num_widens >= 1)
8736             return 3; /* case 7b */
8737           return 0;
8738         default:
8739           assert (0);
8740         }
8741     }
8742   else
8743     {
8744       /* We will need a NOP no matter what, but should we widen
8745          this instruction to help?
8746
8747          This is a RELAX_FRAG_NARROW frag.  */
8748       switch (desired_diff)
8749         {
8750         case 1:
8751           assert (0);
8752           return 0;
8753         case 2:
8754         case 3:
8755           return 0;
8756         case 4:
8757           if (wide_nops >= 1 && num_widens == 1)
8758             return 1; /* case 4a */
8759           return 0;
8760         case 5:
8761           if (wide_nops >= 1 && num_widens == 2)
8762             return 1; /* case 5a */
8763           return 0;
8764         case 6:
8765           if (wide_nops >= 2)
8766             return 0; /* case 6a */
8767           else if (wide_nops >= 1 && num_widens == 3)
8768             return 1; /* case 6b */
8769           return 0;
8770         case 7:
8771           if (wide_nops >= 1 && num_widens == 4)
8772             return 1; /* case 7a */
8773           else if (wide_nops >= 2 && num_widens == 1)
8774             return 1; /* case 7b */
8775           return 0;
8776         default:
8777           assert (0);
8778           return 0;
8779         }
8780     }
8781   assert (0);
8782   return 0;
8783 }
8784
8785
8786 static long
8787 relax_frag_immed (segT segP,
8788                   fragS *fragP,
8789                   long stretch,
8790                   int min_steps,
8791                   xtensa_format fmt,
8792                   int slot,
8793                   int *stretched_p,
8794                   bfd_boolean estimate_only)
8795 {
8796   TInsn tinsn;
8797   vliw_insn orig_vinsn;
8798   int old_size;
8799   bfd_boolean negatable_branch = FALSE;
8800   bfd_boolean branch_jmp_to_next = FALSE;
8801   bfd_boolean wide_insn = FALSE;
8802   xtensa_isa isa = xtensa_default_isa;
8803   IStack istack;
8804   offsetT frag_offset;
8805   int num_steps;
8806   fragS *lit_fragP;
8807   int num_text_bytes, num_literal_bytes;
8808   int literal_diff, total_text_diff, this_text_diff, first;
8809
8810   assert (fragP->fr_opcode != NULL);
8811
8812   xg_init_vinsn (&orig_vinsn);
8813   vinsn_from_chars (&orig_vinsn, fragP->fr_opcode);
8814   if (xtensa_format_num_slots (isa, fmt) > 1)
8815     wide_insn = TRUE;
8816
8817   tinsn = orig_vinsn.slots[slot];
8818   tinsn_immed_from_frag (&tinsn, fragP, slot);
8819
8820   if (estimate_only && xtensa_opcode_is_loop (isa, tinsn.opcode))
8821     return 0;
8822
8823   if (workaround_b_j_loop_end && ! fragP->tc_frag_data.is_no_transform)
8824     branch_jmp_to_next = is_branch_jmp_to_next (&tinsn, fragP);
8825
8826   negatable_branch = (xtensa_opcode_is_branch (isa, tinsn.opcode) == 1);
8827
8828   old_size = xtensa_format_length (isa, fmt);
8829
8830   /* Special case: replace a branch to the next instruction with a NOP.
8831      This is required to work around a hardware bug in T1040.0 and also
8832      serves as an optimization.  */
8833
8834   if (branch_jmp_to_next
8835       && ((old_size == 2) || (old_size == 3))
8836       && !next_frag_is_loop_target (fragP))
8837     return 0;
8838
8839   /* Here is the fun stuff: Get the immediate field from this
8840      instruction.  If it fits, we are done.  If not, find the next
8841      instruction sequence that fits.  */
8842
8843   frag_offset = fragP->fr_opcode - fragP->fr_literal;
8844   istack_init (&istack);
8845   num_steps = xg_assembly_relax (&istack, &tinsn, segP, fragP, frag_offset,
8846                                  min_steps, stretch);
8847   if (num_steps < min_steps)
8848     {
8849       as_fatal (_("internal error: relaxation failed"));
8850       return 0;
8851     }
8852
8853   if (num_steps > RELAX_IMMED_MAXSTEPS)
8854     {
8855       as_fatal (_("internal error: relaxation requires too many steps"));
8856       return 0;
8857     }
8858
8859   fragP->tc_frag_data.slot_subtypes[slot] = (int) RELAX_IMMED + num_steps;
8860
8861   /* Figure out the number of bytes needed.  */
8862   lit_fragP = 0;
8863   num_literal_bytes = get_num_stack_literal_bytes (&istack);
8864   literal_diff =
8865     num_literal_bytes - fragP->tc_frag_data.literal_expansion[slot];
8866   first = 0;
8867   while (istack.insn[first].opcode == XTENSA_UNDEFINED)
8868     first++;
8869   num_text_bytes = get_num_stack_text_bytes (&istack);
8870   if (wide_insn)
8871     {
8872       num_text_bytes += old_size;
8873       if (opcode_fits_format_slot (istack.insn[first].opcode, fmt, slot))
8874         num_text_bytes -= xg_get_single_size (istack.insn[first].opcode);
8875     }
8876   total_text_diff = num_text_bytes - old_size;
8877   this_text_diff = total_text_diff - fragP->tc_frag_data.text_expansion[slot];
8878
8879   /* It MUST get larger.  If not, we could get an infinite loop.  */
8880   assert (num_text_bytes >= 0);
8881   assert (literal_diff >= 0);
8882   assert (total_text_diff >= 0);
8883
8884   fragP->tc_frag_data.text_expansion[slot] = total_text_diff;
8885   fragP->tc_frag_data.literal_expansion[slot] = num_literal_bytes;
8886   assert (fragP->tc_frag_data.text_expansion[slot] >= 0);
8887   assert (fragP->tc_frag_data.literal_expansion[slot] >= 0);
8888
8889   /* Find the associated expandable literal for this.  */
8890   if (literal_diff != 0)
8891     {
8892       lit_fragP = fragP->tc_frag_data.literal_frags[slot];
8893       if (lit_fragP)
8894         {
8895           assert (literal_diff == 4);
8896           lit_fragP->tc_frag_data.unreported_expansion += literal_diff;
8897
8898           /* We expect that the literal section state has NOT been
8899              modified yet.  */
8900           assert (lit_fragP->fr_type == rs_machine_dependent
8901                   && lit_fragP->fr_subtype == RELAX_LITERAL);
8902           lit_fragP->fr_subtype = RELAX_LITERAL_NR;
8903
8904           /* We need to mark this section for another iteration
8905              of relaxation.  */
8906           (*stretched_p)++;
8907         }
8908     }
8909
8910   if (negatable_branch && istack.ninsn > 1)
8911     update_next_frag_state (fragP);
8912
8913   return this_text_diff;
8914 }
8915
8916 \f
8917 /* md_convert_frag Hook and Helper Functions.  */
8918
8919 static void convert_frag_align_next_opcode (fragS *);
8920 static void convert_frag_narrow (segT, fragS *, xtensa_format, int);
8921 static void convert_frag_fill_nop (fragS *);
8922 static void convert_frag_immed (segT, fragS *, int, xtensa_format, int);
8923
8924 void
8925 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec, fragS *fragp)
8926 {
8927   static xtensa_insnbuf vbuf = NULL;
8928   xtensa_isa isa = xtensa_default_isa;
8929   int slot;
8930   int num_slots;
8931   xtensa_format fmt;
8932   char *file_name;
8933   unsigned line;
8934
8935   as_where (&file_name, &line);
8936   new_logical_line (fragp->fr_file, fragp->fr_line);
8937
8938   switch (fragp->fr_subtype)
8939     {
8940     case RELAX_ALIGN_NEXT_OPCODE:
8941       /* Always convert.  */
8942       convert_frag_align_next_opcode (fragp);
8943       break;
8944
8945     case RELAX_DESIRE_ALIGN:
8946       /* Do nothing.  If not aligned already, too bad.  */
8947       break;
8948
8949     case RELAX_LITERAL:
8950     case RELAX_LITERAL_FINAL:
8951       break;
8952
8953     case RELAX_SLOTS:
8954       if (vbuf == NULL)
8955         vbuf = xtensa_insnbuf_alloc (isa);
8956
8957       xtensa_insnbuf_from_chars
8958         (isa, vbuf, (unsigned char *) fragp->fr_opcode, 0);
8959       fmt = xtensa_format_decode (isa, vbuf);
8960       num_slots = xtensa_format_num_slots (isa, fmt);
8961
8962       for (slot = 0; slot < num_slots; slot++)
8963         {
8964           switch (fragp->tc_frag_data.slot_subtypes[slot])
8965             {
8966             case RELAX_NARROW:
8967               convert_frag_narrow (sec, fragp, fmt, slot);
8968               break;
8969
8970             case RELAX_IMMED:
8971             case RELAX_IMMED_STEP1:
8972             case RELAX_IMMED_STEP2:
8973               /* Place the immediate.  */
8974               convert_frag_immed
8975                 (sec, fragp,
8976                  fragp->tc_frag_data.slot_subtypes[slot] - RELAX_IMMED,
8977                  fmt, slot);
8978               break;
8979
8980             default:
8981               /* This is OK because some slots could have
8982                  relaxations and others have none.  */
8983               break;
8984             }
8985         }
8986       break;
8987
8988     case RELAX_UNREACHABLE:
8989       memset (&fragp->fr_literal[fragp->fr_fix], 0, fragp->fr_var);
8990       fragp->fr_fix += fragp->tc_frag_data.text_expansion[0];
8991       fragp->fr_var -= fragp->tc_frag_data.text_expansion[0];
8992       frag_wane (fragp);
8993       break;
8994
8995     case RELAX_MAYBE_UNREACHABLE:
8996     case RELAX_MAYBE_DESIRE_ALIGN:
8997       frag_wane (fragp);
8998       break;
8999
9000     case RELAX_FILL_NOP:
9001       convert_frag_fill_nop (fragp);
9002       break;
9003
9004     case RELAX_LITERAL_NR:
9005       if (use_literal_section)
9006         {
9007           /* This should have been handled during relaxation.  When
9008              relaxing a code segment, literals sometimes need to be
9009              added to the corresponding literal segment.  If that
9010              literal segment has already been relaxed, then we end up
9011              in this situation.  Marking the literal segments as data
9012              would make this happen less often (since GAS always relaxes
9013              code before data), but we could still get into trouble if
9014              there are instructions in a segment that is not marked as
9015              containing code.  Until we can implement a better solution,
9016              cheat and adjust the addresses of all the following frags.
9017              This could break subsequent alignments, but the linker's
9018              literal coalescing will do that anyway.  */
9019
9020           fragS *f;
9021           fragp->fr_subtype = RELAX_LITERAL_FINAL;
9022           assert (fragp->tc_frag_data.unreported_expansion == 4);
9023           memset (&fragp->fr_literal[fragp->fr_fix], 0, 4);
9024           fragp->fr_var -= 4;
9025           fragp->fr_fix += 4;
9026           for (f = fragp->fr_next; f; f = f->fr_next)
9027             f->fr_address += 4;
9028         }
9029       else
9030         as_bad (_("invalid relaxation fragment result"));
9031       break;
9032     }
9033
9034   fragp->fr_var = 0;
9035   new_logical_line (file_name, line);
9036 }
9037
9038
9039 static void
9040 convert_frag_align_next_opcode (fragS *fragp)
9041 {
9042   char *nop_buf;                /* Location for Writing.  */
9043   bfd_boolean use_no_density = fragp->tc_frag_data.is_no_density;
9044   addressT aligned_address;
9045   offsetT fill_size;
9046   int nop, nop_count;
9047
9048   aligned_address = get_noop_aligned_address (fragp, fragp->fr_address +
9049                                               fragp->fr_fix);
9050   fill_size = aligned_address - (fragp->fr_address + fragp->fr_fix);
9051   nop_count = get_text_align_nop_count (fill_size, use_no_density);
9052   nop_buf = fragp->fr_literal + fragp->fr_fix;
9053
9054   for (nop = 0; nop < nop_count; nop++)
9055     {
9056       int nop_size;
9057       nop_size = get_text_align_nth_nop_size (fill_size, nop, use_no_density);
9058
9059       assemble_nop (nop_size, nop_buf);
9060       nop_buf += nop_size;
9061     }
9062
9063   fragp->fr_fix += fill_size;
9064   fragp->fr_var -= fill_size;
9065 }
9066
9067
9068 static void
9069 convert_frag_narrow (segT segP, fragS *fragP, xtensa_format fmt, int slot)
9070 {
9071   TInsn tinsn, single_target;
9072   xtensa_format single_fmt;
9073   int size, old_size, diff;
9074   offsetT frag_offset;
9075
9076   assert (slot == 0);
9077   tinsn_from_chars (&tinsn, fragP->fr_opcode, 0);
9078
9079   if (xtensa_opcode_is_branch (xtensa_default_isa, tinsn.opcode) == 1)
9080     {
9081       assert (fragP->tc_frag_data.text_expansion[0] == 1
9082               || fragP->tc_frag_data.text_expansion[0] == 0);
9083       convert_frag_immed (segP, fragP, fragP->tc_frag_data.text_expansion[0],
9084                           fmt, slot);
9085       return;
9086     }
9087
9088   if (fragP->tc_frag_data.text_expansion[0] == 0)
9089     {
9090       /* No conversion.  */
9091       fragP->fr_var = 0;
9092       return;
9093     }
9094
9095   assert (fragP->fr_opcode != NULL);
9096
9097   /* Frags in this relaxation state should only contain
9098      single instruction bundles.  */
9099   tinsn_immed_from_frag (&tinsn, fragP, 0);
9100
9101   /* Just convert it to a wide form....  */
9102   size = 0;
9103   old_size = xg_get_single_size (tinsn.opcode);
9104
9105   tinsn_init (&single_target);
9106   frag_offset = fragP->fr_opcode - fragP->fr_literal;
9107
9108   if (! xg_is_single_relaxable_insn (&tinsn, &single_target, FALSE))
9109     {
9110       as_bad (_("unable to widen instruction"));
9111       return;
9112     }
9113
9114   size = xg_get_single_size (single_target.opcode);
9115   single_fmt = xg_get_single_format (single_target.opcode);
9116
9117   xg_emit_insn_to_buf (&single_target, single_fmt, fragP->fr_opcode,
9118                        fragP, frag_offset, TRUE);
9119
9120   diff = size - old_size;
9121   assert (diff >= 0);
9122   assert (diff <= fragP->fr_var);
9123   fragP->fr_var -= diff;
9124   fragP->fr_fix += diff;
9125
9126   /* clean it up */
9127   fragP->fr_var = 0;
9128 }
9129
9130
9131 static void
9132 convert_frag_fill_nop (fragS *fragP)
9133 {
9134   char *loc = &fragP->fr_literal[fragP->fr_fix];
9135   int size = fragP->tc_frag_data.text_expansion[0];
9136   assert ((unsigned) size == (fragP->fr_next->fr_address
9137                               - fragP->fr_address - fragP->fr_fix));
9138   if (size == 0)
9139     {
9140       /* No conversion.  */
9141       fragP->fr_var = 0;
9142       return;
9143     }
9144   assemble_nop (size, loc);
9145   fragP->tc_frag_data.is_insn = TRUE;
9146   fragP->fr_var -= size;
9147   fragP->fr_fix += size;
9148   frag_wane (fragP);
9149 }
9150
9151
9152 static fixS *fix_new_exp_in_seg
9153   (segT, subsegT, fragS *, int, int, expressionS *, int,
9154    bfd_reloc_code_real_type);
9155 static void convert_frag_immed_finish_loop (segT, fragS *, TInsn *);
9156
9157 static void
9158 convert_frag_immed (segT segP,
9159                     fragS *fragP,
9160                     int min_steps,
9161                     xtensa_format fmt,
9162                     int slot)
9163 {
9164   char *immed_instr = fragP->fr_opcode;
9165   TInsn orig_tinsn;
9166   bfd_boolean expanded = FALSE;
9167   bfd_boolean branch_jmp_to_next = FALSE;
9168   char *fr_opcode = fragP->fr_opcode;
9169   vliw_insn orig_vinsn;
9170   xtensa_isa isa = xtensa_default_isa;
9171   bfd_boolean wide_insn = FALSE;
9172   int bytes;
9173   bfd_boolean is_loop;
9174
9175   assert (fr_opcode != NULL);
9176
9177   xg_init_vinsn (&orig_vinsn);
9178
9179   vinsn_from_chars (&orig_vinsn, fr_opcode);
9180   if (xtensa_format_num_slots (isa, fmt) > 1)
9181     wide_insn = TRUE;
9182
9183   orig_tinsn = orig_vinsn.slots[slot];
9184   tinsn_immed_from_frag (&orig_tinsn, fragP, slot);
9185
9186   is_loop = xtensa_opcode_is_loop (xtensa_default_isa, orig_tinsn.opcode) == 1;
9187
9188   if (workaround_b_j_loop_end && ! fragP->tc_frag_data.is_no_transform)
9189     branch_jmp_to_next = is_branch_jmp_to_next (&orig_tinsn, fragP);
9190
9191   if (branch_jmp_to_next && !next_frag_is_loop_target (fragP))
9192     {
9193       /* Conversion just inserts a NOP and marks the fix as completed.  */
9194       bytes = xtensa_format_length (isa, fmt);
9195       if (bytes >= 4)
9196         {
9197           orig_vinsn.slots[slot].opcode =
9198             xtensa_format_slot_nop_opcode (isa, orig_vinsn.format, slot);
9199           orig_vinsn.slots[slot].ntok = 0;
9200         }
9201       else
9202         {
9203           bytes += fragP->tc_frag_data.text_expansion[0];
9204           assert (bytes == 2 || bytes == 3);
9205           build_nop (&orig_vinsn.slots[0], bytes);
9206           fragP->fr_fix += fragP->tc_frag_data.text_expansion[0];
9207         }
9208       vinsn_to_insnbuf (&orig_vinsn, fr_opcode, frag_now, FALSE);
9209       xtensa_insnbuf_to_chars
9210         (isa, orig_vinsn.insnbuf, (unsigned char *) fr_opcode, 0);
9211       fragP->fr_var = 0;
9212     }
9213   else
9214     {
9215       /* Here is the fun stuff:  Get the immediate field from this
9216          instruction.  If it fits, we're done.  If not, find the next
9217          instruction sequence that fits.  */
9218
9219       IStack istack;
9220       int i;
9221       symbolS *lit_sym = NULL;
9222       int total_size = 0;
9223       int target_offset = 0;
9224       int old_size;
9225       int diff;
9226       symbolS *gen_label = NULL;
9227       offsetT frag_offset;
9228       bfd_boolean first = TRUE;
9229       bfd_boolean last_is_jump;
9230
9231       /* It does not fit.  Find something that does and
9232          convert immediately.  */
9233       frag_offset = fr_opcode - fragP->fr_literal;
9234       istack_init (&istack);
9235       xg_assembly_relax (&istack, &orig_tinsn,
9236                          segP, fragP, frag_offset, min_steps, 0);
9237
9238       old_size = xtensa_format_length (isa, fmt);
9239
9240       /* Assemble this right inline.  */
9241
9242       /* First, create the mapping from a label name to the REAL label.  */
9243       target_offset = 0;
9244       for (i = 0; i < istack.ninsn; i++)
9245         {
9246           TInsn *tinsn = &istack.insn[i];
9247           fragS *lit_frag;
9248
9249           switch (tinsn->insn_type)
9250             {
9251             case ITYPE_LITERAL:
9252               if (lit_sym != NULL)
9253                 as_bad (_("multiple literals in expansion"));
9254               /* First find the appropriate space in the literal pool.  */
9255               lit_frag = fragP->tc_frag_data.literal_frags[slot];
9256               if (lit_frag == NULL)
9257                 as_bad (_("no registered fragment for literal"));
9258               if (tinsn->ntok != 1)
9259                 as_bad (_("number of literal tokens != 1"));
9260
9261               /* Set the literal symbol and add a fixup.  */
9262               lit_sym = lit_frag->fr_symbol;
9263               break;
9264
9265             case ITYPE_LABEL:
9266               if (align_targets && !is_loop)
9267                 {
9268                   fragS *unreach = fragP->fr_next;
9269                   while (!(unreach->fr_type == rs_machine_dependent
9270                            && (unreach->fr_subtype == RELAX_MAYBE_UNREACHABLE
9271                                || unreach->fr_subtype == RELAX_UNREACHABLE)))
9272                     {
9273                       unreach = unreach->fr_next;
9274                     }
9275
9276                   assert (unreach->fr_type == rs_machine_dependent
9277                           && (unreach->fr_subtype == RELAX_MAYBE_UNREACHABLE
9278                               || unreach->fr_subtype == RELAX_UNREACHABLE));
9279
9280                   target_offset += unreach->tc_frag_data.text_expansion[0];
9281                 }
9282               assert (gen_label == NULL);
9283               gen_label = symbol_new (FAKE_LABEL_NAME, now_seg,
9284                                       fr_opcode - fragP->fr_literal
9285                                       + target_offset, fragP);
9286               break;
9287
9288             case ITYPE_INSN:
9289               if (first && wide_insn)
9290                 {
9291                   target_offset += xtensa_format_length (isa, fmt);
9292                   first = FALSE;
9293                   if (!opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9294                     target_offset += xg_get_single_size (tinsn->opcode);
9295                 }
9296               else
9297                 target_offset += xg_get_single_size (tinsn->opcode);
9298               break;
9299             }
9300         }
9301
9302       total_size = 0;
9303       first = TRUE;
9304       last_is_jump = FALSE;
9305       for (i = 0; i < istack.ninsn; i++)
9306         {
9307           TInsn *tinsn = &istack.insn[i];
9308           fragS *lit_frag;
9309           int size;
9310           segT target_seg;
9311           bfd_reloc_code_real_type reloc_type;
9312
9313           switch (tinsn->insn_type)
9314             {
9315             case ITYPE_LITERAL:
9316               lit_frag = fragP->tc_frag_data.literal_frags[slot];
9317               /* Already checked.  */
9318               assert (lit_frag != NULL);
9319               assert (lit_sym != NULL);
9320               assert (tinsn->ntok == 1);
9321               /* Add a fixup.  */
9322               target_seg = S_GET_SEGMENT (lit_sym);
9323               assert (target_seg);
9324               if (tinsn->tok[0].X_op == O_pltrel)
9325                 reloc_type = BFD_RELOC_XTENSA_PLT;
9326               else
9327                 reloc_type = BFD_RELOC_32;
9328               fix_new_exp_in_seg (target_seg, 0, lit_frag, 0, 4,
9329                                   &tinsn->tok[0], FALSE, reloc_type);
9330               break;
9331
9332             case ITYPE_LABEL:
9333               break;
9334
9335             case ITYPE_INSN:
9336               xg_resolve_labels (tinsn, gen_label);
9337               xg_resolve_literals (tinsn, lit_sym);
9338               if (wide_insn && first)
9339                 {
9340                   first = FALSE;
9341                   if (opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9342                     {
9343                       tinsn->record_fix = TRUE;
9344                       orig_vinsn.slots[slot] = *tinsn;
9345                     }
9346                   else
9347                     {
9348                       orig_vinsn.slots[slot].opcode =
9349                         xtensa_format_slot_nop_opcode (isa, fmt, slot);
9350                       orig_vinsn.slots[slot].ntok = 0;
9351                       orig_vinsn.slots[slot].record_fix = FALSE;
9352                     }
9353                   vinsn_to_insnbuf (&orig_vinsn, immed_instr, fragP, TRUE);
9354                   xtensa_insnbuf_to_chars (isa, orig_vinsn.insnbuf,
9355                                            (unsigned char *) immed_instr, 0);
9356                   fragP->tc_frag_data.is_insn = TRUE;
9357                   size = xtensa_format_length (isa, fmt);
9358                   if (!opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9359                     {
9360                       xtensa_format single_fmt =
9361                         xg_get_single_format (tinsn->opcode);
9362
9363                       xg_emit_insn_to_buf
9364                         (tinsn, single_fmt, immed_instr + size, fragP,
9365                          immed_instr - fragP->fr_literal + size, TRUE);
9366                       size += xg_get_single_size (tinsn->opcode);
9367                     }
9368                 }
9369               else
9370                 {
9371                   xtensa_format single_format;
9372                   size = xg_get_single_size (tinsn->opcode);
9373                   single_format = xg_get_single_format (tinsn->opcode);
9374                   xg_emit_insn_to_buf (tinsn, single_format, immed_instr,
9375                                        fragP,
9376                                        immed_instr - fragP->fr_literal, TRUE);
9377                 }
9378               immed_instr += size;
9379               total_size += size;
9380               break;
9381             }
9382         }
9383
9384       diff = total_size - old_size;
9385       assert (diff >= 0);
9386       if (diff != 0)
9387         expanded = TRUE;
9388       assert (diff <= fragP->fr_var);
9389       fragP->fr_var -= diff;
9390       fragP->fr_fix += diff;
9391     }
9392
9393   /* Clean it up.  */
9394   xg_free_vinsn (&orig_vinsn);
9395
9396   /* Check for undefined immediates in LOOP instructions.  */
9397   if (is_loop)
9398     {
9399       symbolS *sym;
9400       sym = orig_tinsn.tok[1].X_add_symbol;
9401       if (sym != NULL && !S_IS_DEFINED (sym))
9402         {
9403           as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym));
9404           return;
9405         }
9406       sym = orig_tinsn.tok[1].X_op_symbol;
9407       if (sym != NULL && !S_IS_DEFINED (sym))
9408         {
9409           as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym));
9410           return;
9411         }
9412     }
9413
9414   if (expanded && xtensa_opcode_is_loop (isa, orig_tinsn.opcode) == 1)
9415     convert_frag_immed_finish_loop (segP, fragP, &orig_tinsn);
9416
9417   if (expanded && is_direct_call_opcode (orig_tinsn.opcode))
9418     {
9419       /* Add an expansion note on the expanded instruction.  */
9420       fix_new_exp_in_seg (now_seg, 0, fragP, fr_opcode - fragP->fr_literal, 4,
9421                           &orig_tinsn.tok[0], TRUE,
9422                           BFD_RELOC_XTENSA_ASM_EXPAND);
9423     }
9424 }
9425
9426
9427 /* Add a new fix expression into the desired segment.  We have to
9428    switch to that segment to do this.  */
9429
9430 static fixS *
9431 fix_new_exp_in_seg (segT new_seg,
9432                     subsegT new_subseg,
9433                     fragS *frag,
9434                     int where,
9435                     int size,
9436                     expressionS *exp,
9437                     int pcrel,
9438                     bfd_reloc_code_real_type r_type)
9439 {
9440   fixS *new_fix;
9441   segT seg = now_seg;
9442   subsegT subseg = now_subseg;
9443
9444   assert (new_seg != 0);
9445   subseg_set (new_seg, new_subseg);
9446
9447   new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
9448   subseg_set (seg, subseg);
9449   return new_fix;
9450 }
9451
9452
9453 /* Relax a loop instruction so that it can span loop >256 bytes.
9454
9455                   loop    as, .L1
9456           .L0:
9457                   rsr     as, LEND
9458                   wsr     as, LBEG
9459                   addi    as, as, lo8 (label-.L1)
9460                   addmi   as, as, mid8 (label-.L1)
9461                   wsr     as, LEND
9462                   isync
9463                   rsr     as, LCOUNT
9464                   addi    as, as, 1
9465           .L1:
9466                   <<body>>
9467           label:
9468 */
9469
9470 static void
9471 convert_frag_immed_finish_loop (segT segP, fragS *fragP, TInsn *tinsn)
9472 {
9473   TInsn loop_insn;
9474   TInsn addi_insn;
9475   TInsn addmi_insn;
9476   unsigned long target;
9477   static xtensa_insnbuf insnbuf = NULL;
9478   unsigned int loop_length, loop_length_hi, loop_length_lo;
9479   xtensa_isa isa = xtensa_default_isa;
9480   addressT loop_offset;
9481   addressT addi_offset = 9;
9482   addressT addmi_offset = 12;
9483   fragS *next_fragP;
9484   int target_count;
9485
9486   if (!insnbuf)
9487     insnbuf = xtensa_insnbuf_alloc (isa);
9488
9489   /* Get the loop offset.  */
9490   loop_offset = get_expanded_loop_offset (tinsn->opcode);
9491
9492   /* Validate that there really is a LOOP at the loop_offset.  Because
9493      loops are not bundleable, we can assume that the instruction will be
9494      in slot 0.  */
9495   tinsn_from_chars (&loop_insn, fragP->fr_opcode + loop_offset, 0);
9496   tinsn_immed_from_frag (&loop_insn, fragP, 0);
9497
9498   assert (xtensa_opcode_is_loop (isa, loop_insn.opcode) == 1);
9499   addi_offset += loop_offset;
9500   addmi_offset += loop_offset;
9501
9502   assert (tinsn->ntok == 2);
9503   if (tinsn->tok[1].X_op == O_constant)
9504     target = tinsn->tok[1].X_add_number;
9505   else if (tinsn->tok[1].X_op == O_symbol)
9506     {
9507       /* Find the fragment.  */
9508       symbolS *sym = tinsn->tok[1].X_add_symbol;
9509       assert (S_GET_SEGMENT (sym) == segP
9510               || S_GET_SEGMENT (sym) == absolute_section);
9511       target = (S_GET_VALUE (sym) + tinsn->tok[1].X_add_number);
9512     }
9513   else
9514     {
9515       as_bad (_("invalid expression evaluation type %d"), tinsn->tok[1].X_op);
9516       target = 0;
9517     }
9518
9519   know (symbolP);
9520   know (symbolP->sy_frag);
9521   know (!(S_GET_SEGMENT (symbolP) == absolute_section)
9522         || symbol_get_frag (symbolP) == &zero_address_frag);
9523
9524   loop_length = target - (fragP->fr_address + fragP->fr_fix);
9525   loop_length_hi = loop_length & ~0x0ff;
9526   loop_length_lo = loop_length & 0x0ff;
9527   if (loop_length_lo >= 128)
9528     {
9529       loop_length_lo -= 256;
9530       loop_length_hi += 256;
9531     }
9532
9533   /* Because addmi sign-extends the immediate, 'loop_length_hi' can be at most
9534      32512.  If the loop is larger than that, then we just fail.  */
9535   if (loop_length_hi > 32512)
9536     as_bad_where (fragP->fr_file, fragP->fr_line,
9537                   _("loop too long for LOOP instruction"));
9538
9539   tinsn_from_chars (&addi_insn, fragP->fr_opcode + addi_offset, 0);
9540   assert (addi_insn.opcode == xtensa_addi_opcode);
9541
9542   tinsn_from_chars (&addmi_insn, fragP->fr_opcode + addmi_offset, 0);
9543   assert (addmi_insn.opcode == xtensa_addmi_opcode);
9544
9545   set_expr_const (&addi_insn.tok[2], loop_length_lo);
9546   tinsn_to_insnbuf (&addi_insn, insnbuf);
9547
9548   fragP->tc_frag_data.is_insn = TRUE;
9549   xtensa_insnbuf_to_chars
9550     (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addi_offset, 0);
9551
9552   set_expr_const (&addmi_insn.tok[2], loop_length_hi);
9553   tinsn_to_insnbuf (&addmi_insn, insnbuf);
9554   xtensa_insnbuf_to_chars
9555     (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addmi_offset, 0);
9556
9557   /* Walk through all of the frags from here to the loop end
9558      and mark them as no_transform to keep them from being modified
9559      by the linker.  If we ever have a relocation for the
9560      addi/addmi of the difference of two symbols we can remove this.  */
9561
9562   target_count = 0;
9563   for (next_fragP = fragP; next_fragP != NULL;
9564        next_fragP = next_fragP->fr_next)
9565     {
9566       next_fragP->tc_frag_data.is_no_transform = TRUE;
9567       if (next_fragP->tc_frag_data.is_loop_target)
9568         target_count++;
9569       if (target_count == 2)
9570         break;
9571     }
9572 }
9573
9574 \f
9575 /* A map that keeps information on a per-subsegment basis.  This is
9576    maintained during initial assembly, but is invalid once the
9577    subsegments are smashed together.  I.E., it cannot be used during
9578    the relaxation.  */
9579
9580 typedef struct subseg_map_struct
9581 {
9582   /* the key */
9583   segT seg;
9584   subsegT subseg;
9585
9586   /* the data */
9587   unsigned flags;
9588   float total_freq;     /* fall-through + branch target frequency */
9589   float target_freq;    /* branch target frequency alone */
9590
9591   struct subseg_map_struct *next;
9592 } subseg_map;
9593
9594
9595 static subseg_map *sseg_map = NULL;
9596
9597 static subseg_map *
9598 get_subseg_info (segT seg, subsegT subseg)
9599 {
9600   subseg_map *subseg_e;
9601
9602   for (subseg_e = sseg_map; subseg_e; subseg_e = subseg_e->next)
9603     {
9604       if (seg == subseg_e->seg && subseg == subseg_e->subseg)
9605         break;
9606     }
9607   return subseg_e;
9608 }
9609
9610
9611 static subseg_map *
9612 add_subseg_info (segT seg, subsegT subseg)
9613 {
9614   subseg_map *subseg_e = (subseg_map *) xmalloc (sizeof (subseg_map));
9615   memset (subseg_e, 0, sizeof (subseg_map));
9616   subseg_e->seg = seg;
9617   subseg_e->subseg = subseg;
9618   subseg_e->flags = 0;
9619   /* Start off considering every branch target very important.  */
9620   subseg_e->target_freq = 1.0;
9621   subseg_e->total_freq = 1.0;
9622   subseg_e->next = sseg_map;
9623   sseg_map = subseg_e;
9624   return subseg_e;
9625 }
9626
9627
9628 static unsigned
9629 get_last_insn_flags (segT seg, subsegT subseg)
9630 {
9631   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9632   if (subseg_e)
9633     return subseg_e->flags;
9634   return 0;
9635 }
9636
9637
9638 static void
9639 set_last_insn_flags (segT seg,
9640                      subsegT subseg,
9641                      unsigned fl,
9642                      bfd_boolean val)
9643 {
9644   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9645   if (! subseg_e)
9646     subseg_e = add_subseg_info (seg, subseg);
9647   if (val)
9648     subseg_e->flags |= fl;
9649   else
9650     subseg_e->flags &= ~fl;
9651 }
9652
9653
9654 static float
9655 get_subseg_total_freq (segT seg, subsegT subseg)
9656 {
9657   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9658   if (subseg_e)
9659     return subseg_e->total_freq;
9660   return 1.0;
9661 }
9662
9663
9664 static float
9665 get_subseg_target_freq (segT seg, subsegT subseg)
9666 {
9667   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9668   if (subseg_e)
9669     return subseg_e->target_freq;
9670   return 1.0;
9671 }
9672
9673
9674 static void
9675 set_subseg_freq (segT seg, subsegT subseg, float total_f, float target_f)
9676 {
9677   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9678   if (! subseg_e)
9679     subseg_e = add_subseg_info (seg, subseg);
9680   subseg_e->total_freq = total_f;
9681   subseg_e->target_freq = target_f;
9682 }
9683
9684 \f
9685 /* Segment Lists and emit_state Stuff.  */
9686
9687 static void
9688 xtensa_move_seg_list_to_beginning (seg_list *head)
9689 {
9690   head = head->next;
9691   while (head)
9692     {
9693       segT literal_section = head->seg;
9694
9695       /* Move the literal section to the front of the section list.  */
9696       assert (literal_section);
9697       if (literal_section != stdoutput->sections)
9698         {
9699           bfd_section_list_remove (stdoutput, literal_section);
9700           bfd_section_list_prepend (stdoutput, literal_section);
9701         }
9702       head = head->next;
9703     }
9704 }
9705
9706
9707 static void mark_literal_frags (seg_list *);
9708
9709 static void
9710 xtensa_move_literals (void)
9711 {
9712   seg_list *segment;
9713   frchainS *frchain_from, *frchain_to;
9714   fragS *search_frag, *next_frag, *last_frag, *literal_pool, *insert_after;
9715   fragS **frag_splice;
9716   emit_state state;
9717   segT dest_seg;
9718   fixS *fix, *next_fix, **fix_splice;
9719   sym_list *lit;
9720
9721   mark_literal_frags (literal_head->next);
9722   mark_literal_frags (init_literal_head->next);
9723   mark_literal_frags (fini_literal_head->next);
9724
9725   if (use_literal_section)
9726     return;
9727
9728   segment = literal_head->next;
9729   while (segment)
9730     {
9731       frchain_from = seg_info (segment->seg)->frchainP;
9732       search_frag = frchain_from->frch_root;
9733       literal_pool = NULL;
9734       frchain_to = NULL;
9735       frag_splice = &(frchain_from->frch_root);
9736
9737       while (!search_frag->tc_frag_data.literal_frag)
9738         {
9739           assert (search_frag->fr_fix == 0
9740                   || search_frag->fr_type == rs_align);
9741           search_frag = search_frag->fr_next;
9742         }
9743
9744       assert (search_frag->tc_frag_data.literal_frag->fr_subtype
9745               == RELAX_LITERAL_POOL_BEGIN);
9746       xtensa_switch_section_emit_state (&state, segment->seg, 0);
9747
9748       /* Make sure that all the frags in this series are closed, and
9749          that there is at least one left over of zero-size.  This
9750          prevents us from making a segment with an frchain without any
9751          frags in it.  */
9752       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9753       xtensa_set_frag_assembly_state (frag_now);
9754       last_frag = frag_now;
9755       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9756       xtensa_set_frag_assembly_state (frag_now);
9757
9758       while (search_frag != frag_now)
9759         {
9760           next_frag = search_frag->fr_next;
9761
9762           /* First, move the frag out of the literal section and
9763              to the appropriate place.  */
9764           if (search_frag->tc_frag_data.literal_frag)
9765             {
9766               literal_pool = search_frag->tc_frag_data.literal_frag;
9767               assert (literal_pool->fr_subtype == RELAX_LITERAL_POOL_BEGIN);
9768               frchain_to = literal_pool->tc_frag_data.lit_frchain;
9769               assert (frchain_to);
9770             }
9771           insert_after = literal_pool;
9772
9773           while (insert_after->fr_next->fr_subtype != RELAX_LITERAL_POOL_END)
9774             insert_after = insert_after->fr_next;
9775
9776           dest_seg = insert_after->fr_next->tc_frag_data.lit_seg;
9777
9778           *frag_splice = next_frag;
9779           search_frag->fr_next = insert_after->fr_next;
9780           insert_after->fr_next = search_frag;
9781           search_frag->tc_frag_data.lit_seg = dest_seg;
9782
9783           /* Now move any fixups associated with this frag to the
9784              right section.  */
9785           fix = frchain_from->fix_root;
9786           fix_splice = &(frchain_from->fix_root);
9787           while (fix)
9788             {
9789               next_fix = fix->fx_next;
9790               if (fix->fx_frag == search_frag)
9791                 {
9792                   *fix_splice = next_fix;
9793                   fix->fx_next = frchain_to->fix_root;
9794                   frchain_to->fix_root = fix;
9795                   if (frchain_to->fix_tail == NULL)
9796                     frchain_to->fix_tail = fix;
9797                 }
9798               else
9799                 fix_splice = &(fix->fx_next);
9800               fix = next_fix;
9801             }
9802           search_frag = next_frag;
9803         }
9804
9805       if (frchain_from->fix_root != NULL)
9806         {
9807           frchain_from = seg_info (segment->seg)->frchainP;
9808           as_warn (_("fixes not all moved from %s"), segment->seg->name);
9809
9810           assert (frchain_from->fix_root == NULL);
9811         }
9812       frchain_from->fix_tail = NULL;
9813       xtensa_restore_emit_state (&state);
9814       segment = segment->next;
9815     }
9816
9817   /* Now fix up the SEGMENT value for all the literal symbols.  */
9818   for (lit = literal_syms; lit; lit = lit->next)
9819     {
9820       symbolS *lit_sym = lit->sym;
9821       segT dest_seg = symbol_get_frag (lit_sym)->tc_frag_data.lit_seg;
9822       if (dest_seg)
9823         S_SET_SEGMENT (lit_sym, dest_seg);
9824     }
9825 }
9826
9827
9828 /* Walk over all the frags for segments in a list and mark them as
9829    containing literals.  As clunky as this is, we can't rely on frag_var
9830    and frag_variant to get called in all situations.  */
9831
9832 static void
9833 mark_literal_frags (seg_list *segment)
9834 {
9835   frchainS *frchain_from;
9836   fragS *search_frag;
9837
9838   while (segment)
9839     {
9840       frchain_from = seg_info (segment->seg)->frchainP;
9841       search_frag = frchain_from->frch_root;
9842       while (search_frag)
9843         {
9844           search_frag->tc_frag_data.is_literal = TRUE;
9845           search_frag = search_frag->fr_next;
9846         }
9847       segment = segment->next;
9848     }
9849 }
9850
9851
9852 static void
9853 xtensa_reorder_seg_list (seg_list *head, segT after)
9854 {
9855   /* Move all of the sections in the section list to come
9856      after "after" in the gnu segment list.  */
9857
9858   head = head->next;
9859   while (head)
9860     {
9861       segT literal_section = head->seg;
9862
9863       /* Move the literal section after "after".  */
9864       assert (literal_section);
9865       if (literal_section != after)
9866         {
9867           bfd_section_list_remove (stdoutput, literal_section);
9868           bfd_section_list_insert_after (stdoutput, after, literal_section);
9869         }
9870
9871       head = head->next;
9872     }
9873 }
9874
9875
9876 /* Push all the literal segments to the end of the gnu list.  */
9877
9878 static void
9879 xtensa_reorder_segments (void)
9880 {
9881   segT sec;
9882   segT last_sec = 0;
9883   int old_count = 0;
9884   int new_count = 0;
9885
9886   for (sec = stdoutput->sections; sec != NULL; sec = sec->next)
9887     {
9888       last_sec = sec;
9889       old_count++;
9890     }
9891
9892   /* Now that we have the last section, push all the literal
9893      sections to the end.  */
9894   xtensa_reorder_seg_list (literal_head, last_sec);
9895   xtensa_reorder_seg_list (init_literal_head, last_sec);
9896   xtensa_reorder_seg_list (fini_literal_head, last_sec);
9897
9898   /* Now perform the final error check.  */
9899   for (sec = stdoutput->sections; sec != NULL; sec = sec->next)
9900     new_count++;
9901   assert (new_count == old_count);
9902 }
9903
9904
9905 /* Change the emit state (seg, subseg, and frag related stuff) to the
9906    correct location.  Return a emit_state which can be passed to
9907    xtensa_restore_emit_state to return to current fragment.  */
9908
9909 static void
9910 xtensa_switch_to_literal_fragment (emit_state *result)
9911 {
9912   if (directive_state[directive_absolute_literals])
9913     {
9914       cache_literal_section (0, default_lit_sections.lit4_seg_name,
9915                              &default_lit_sections.lit4_seg, FALSE);
9916       xtensa_switch_section_emit_state (result,
9917                                         default_lit_sections.lit4_seg, 0);
9918     }
9919   else
9920     xtensa_switch_to_non_abs_literal_fragment (result);
9921
9922   /* Do a 4-byte align here.  */
9923   frag_align (2, 0, 0);
9924   record_alignment (now_seg, 2);
9925 }
9926
9927
9928 static void
9929 xtensa_switch_to_non_abs_literal_fragment (emit_state *result)
9930 {
9931   /* When we mark a literal pool location, we want to put a frag in
9932      the literal pool that points to it.  But to do that, we want to
9933      switch_to_literal_fragment.  But literal sections don't have
9934      literal pools, so their location is always null, so we would
9935      recurse forever.  This is kind of hacky, but it works.  */
9936
9937   static bfd_boolean recursive = FALSE;
9938   fragS *pool_location = get_literal_pool_location (now_seg);
9939   bfd_boolean is_init =
9940     (now_seg && !strcmp (segment_name (now_seg), INIT_SECTION_NAME));
9941
9942   bfd_boolean is_fini =
9943     (now_seg && !strcmp (segment_name (now_seg), FINI_SECTION_NAME));
9944
9945   if (pool_location == NULL
9946       && !use_literal_section
9947       && !recursive
9948       && !is_init && ! is_fini)
9949     {
9950       as_bad (_("literal pool location required for text-section-literals; specify with .literal_position"));
9951       recursive = TRUE;
9952       xtensa_mark_literal_pool_location ();
9953       recursive = FALSE;
9954     }
9955
9956   /* Special case: If we are in the ".fini" or ".init" section, then
9957      we will ALWAYS be generating to the ".fini.literal" and
9958      ".init.literal" sections.  */
9959
9960   if (is_init)
9961     {
9962       cache_literal_section (init_literal_head,
9963                              default_lit_sections.init_lit_seg_name,
9964                              &default_lit_sections.init_lit_seg, TRUE);
9965       xtensa_switch_section_emit_state (result,
9966                                         default_lit_sections.init_lit_seg, 0);
9967     }
9968   else if (is_fini)
9969     {
9970       cache_literal_section (fini_literal_head,
9971                              default_lit_sections.fini_lit_seg_name,
9972                              &default_lit_sections.fini_lit_seg, TRUE);
9973       xtensa_switch_section_emit_state (result,
9974                                         default_lit_sections.fini_lit_seg, 0);
9975     }
9976   else
9977     {
9978       cache_literal_section (literal_head,
9979                              default_lit_sections.lit_seg_name,
9980                              &default_lit_sections.lit_seg, TRUE);
9981       xtensa_switch_section_emit_state (result,
9982                                         default_lit_sections.lit_seg, 0);
9983     }
9984
9985   if (!use_literal_section
9986       && !is_init && !is_fini
9987       && get_literal_pool_location (now_seg) != pool_location)
9988     {
9989       /* Close whatever frag is there.  */
9990       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9991       xtensa_set_frag_assembly_state (frag_now);
9992       frag_now->tc_frag_data.literal_frag = pool_location;
9993       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9994       xtensa_set_frag_assembly_state (frag_now);
9995     }
9996 }
9997
9998
9999 /* Call this function before emitting data into the literal section.
10000    This is a helper function for xtensa_switch_to_literal_fragment.
10001    This is similar to a .section new_now_seg subseg. */
10002
10003 static void
10004 xtensa_switch_section_emit_state (emit_state *state,
10005                                   segT new_now_seg,
10006                                   subsegT new_now_subseg)
10007 {
10008   state->name = now_seg->name;
10009   state->now_seg = now_seg;
10010   state->now_subseg = now_subseg;
10011   state->generating_literals = generating_literals;
10012   generating_literals++;
10013   subseg_set (new_now_seg, new_now_subseg);
10014 }
10015
10016
10017 /* Use to restore the emitting into the normal place.  */
10018
10019 static void
10020 xtensa_restore_emit_state (emit_state *state)
10021 {
10022   generating_literals = state->generating_literals;
10023   subseg_set (state->now_seg, state->now_subseg);
10024 }
10025
10026
10027 /* Get a segment of a given name.  If the segment is already
10028    present, return it; otherwise, create a new one.  */
10029
10030 static void
10031 cache_literal_section (seg_list *head,
10032                        const char *name,
10033                        segT *pseg,
10034                        bfd_boolean is_code)
10035 {
10036   segT current_section = now_seg;
10037   int current_subsec = now_subseg;
10038   segT seg;
10039
10040   if (*pseg != 0)
10041     return;
10042
10043   /* Check if the named section exists.  */
10044   for (seg = stdoutput->sections; seg; seg = seg->next)
10045     {
10046       if (!strcmp (segment_name (seg), name))
10047         break;
10048     }
10049
10050   if (!seg)
10051     {
10052       /* Create a new literal section.  */
10053       seg = subseg_new (name, (subsegT) 0);
10054       if (head)
10055         {
10056           /* Add the newly created literal segment to the specified list.  */
10057           seg_list *n = (seg_list *) xmalloc (sizeof (seg_list));
10058           n->seg = seg;
10059           n->next = head->next;
10060           head->next = n;
10061         }
10062       bfd_set_section_flags (stdoutput, seg, SEC_HAS_CONTENTS |
10063                              SEC_READONLY | SEC_ALLOC | SEC_LOAD
10064                              | (is_code ? SEC_CODE : SEC_DATA));
10065       bfd_set_section_alignment (stdoutput, seg, 2);
10066     }
10067
10068   *pseg = seg;
10069   subseg_set (current_section, current_subsec);
10070 }
10071
10072 \f
10073 /* Property Tables Stuff.  */
10074
10075 #define XTENSA_INSN_SEC_NAME ".xt.insn"
10076 #define XTENSA_LIT_SEC_NAME ".xt.lit"
10077 #define XTENSA_PROP_SEC_NAME ".xt.prop"
10078
10079 typedef bfd_boolean (*frag_predicate) (const fragS *);
10080 typedef void (*frag_flags_fn) (const fragS *, frag_flags *);
10081
10082 static bfd_boolean get_frag_is_literal (const fragS *);
10083 static void xtensa_create_property_segments
10084   (frag_predicate, frag_predicate, const char *, xt_section_type);
10085 static void xtensa_create_xproperty_segments
10086   (frag_flags_fn, const char *, xt_section_type);
10087 static segment_info_type *retrieve_segment_info (segT);
10088 static segT retrieve_xtensa_section (char *);
10089 static bfd_boolean section_has_property (segT, frag_predicate);
10090 static bfd_boolean section_has_xproperty (segT, frag_flags_fn);
10091 static void add_xt_block_frags
10092   (segT, segT, xtensa_block_info **, frag_predicate, frag_predicate);
10093 static bfd_boolean xtensa_frag_flags_is_empty (const frag_flags *);
10094 static void xtensa_frag_flags_init (frag_flags *);
10095 static void get_frag_property_flags (const fragS *, frag_flags *);
10096 static bfd_vma frag_flags_to_number (const frag_flags *);
10097 static void add_xt_prop_frags
10098   (segT, segT, xtensa_block_info **, frag_flags_fn);
10099
10100 /* Set up property tables after relaxation.  */
10101
10102 void
10103 xtensa_post_relax_hook (void)
10104 {
10105   xtensa_move_seg_list_to_beginning (literal_head);
10106   xtensa_move_seg_list_to_beginning (init_literal_head);
10107   xtensa_move_seg_list_to_beginning (fini_literal_head);
10108
10109   xtensa_find_unmarked_state_frags ();
10110
10111   if (use_literal_section)
10112     xtensa_create_property_segments (get_frag_is_literal,
10113                                      NULL,
10114                                      XTENSA_LIT_SEC_NAME,
10115                                      xt_literal_sec);
10116   xtensa_create_xproperty_segments (get_frag_property_flags,
10117                                     XTENSA_PROP_SEC_NAME,
10118                                     xt_prop_sec);
10119
10120   if (warn_unaligned_branch_targets)
10121     bfd_map_over_sections (stdoutput, xtensa_find_unaligned_branch_targets, 0);
10122   bfd_map_over_sections (stdoutput, xtensa_find_unaligned_loops, 0);
10123 }
10124
10125
10126 /* This function is only meaningful after xtensa_move_literals.  */
10127
10128 static bfd_boolean
10129 get_frag_is_literal (const fragS *fragP)
10130 {
10131   assert (fragP != NULL);
10132   return fragP->tc_frag_data.is_literal;
10133 }
10134
10135
10136 static void
10137 xtensa_create_property_segments (frag_predicate property_function,
10138                                  frag_predicate end_property_function,
10139                                  const char *section_name_base,
10140                                  xt_section_type sec_type)
10141 {
10142   segT *seclist;
10143
10144   /* Walk over all of the current segments.
10145      Walk over each fragment
10146      For each non-empty fragment,
10147      Build a property record (append where possible).  */
10148
10149   for (seclist = &stdoutput->sections;
10150        seclist && *seclist;
10151        seclist = &(*seclist)->next)
10152     {
10153       segT sec = *seclist;
10154       flagword flags;
10155
10156       flags = bfd_get_section_flags (stdoutput, sec);
10157       if (flags & SEC_DEBUGGING)
10158         continue;
10159       if (!(flags & SEC_ALLOC))
10160         continue;
10161
10162       if (section_has_property (sec, property_function))
10163         {
10164           char *property_section_name =
10165             xtensa_get_property_section_name (sec, section_name_base);
10166           segT insn_sec = retrieve_xtensa_section (property_section_name);
10167           segment_info_type *xt_seg_info = retrieve_segment_info (insn_sec);
10168           xtensa_block_info **xt_blocks =
10169             &xt_seg_info->tc_segment_info_data.blocks[sec_type];
10170           /* Walk over all of the frchains here and add new sections.  */
10171           add_xt_block_frags (sec, insn_sec, xt_blocks, property_function,
10172                               end_property_function);
10173         }
10174     }
10175
10176   /* Now we fill them out....  */
10177
10178   for (seclist = &stdoutput->sections;
10179        seclist && *seclist;
10180        seclist = &(*seclist)->next)
10181     {
10182       segment_info_type *seginfo;
10183       xtensa_block_info *block;
10184       segT sec = *seclist;
10185
10186       seginfo = seg_info (sec);
10187       block = seginfo->tc_segment_info_data.blocks[sec_type];
10188
10189       if (block)
10190         {
10191           xtensa_block_info *cur_block;
10192           /* This is a section with some data.  */
10193           int num_recs = 0;
10194           bfd_size_type rec_size;
10195
10196           for (cur_block = block; cur_block; cur_block = cur_block->next)
10197             num_recs++;
10198
10199           rec_size = num_recs * 8;
10200           bfd_set_section_size (stdoutput, sec, rec_size);
10201
10202           /* In order to make this work with the assembler, we have to
10203              build some frags and then build the "fixups" for it.  It
10204              would be easier to just set the contents then set the
10205              arlents.  */
10206
10207           if (num_recs)
10208             {
10209               /* Allocate a fragment and leak it.  */
10210               fragS *fragP;
10211               bfd_size_type frag_size;
10212               fixS *fixes;
10213               frchainS *frchainP;
10214               int i;
10215               char *frag_data;
10216
10217               frag_size = sizeof (fragS) + rec_size;
10218               fragP = (fragS *) xmalloc (frag_size);
10219
10220               memset (fragP, 0, frag_size);
10221               fragP->fr_address = 0;
10222               fragP->fr_next = NULL;
10223               fragP->fr_fix = rec_size;
10224               fragP->fr_var = 0;
10225               fragP->fr_type = rs_fill;
10226               /* The rest are zeros.  */
10227
10228               frchainP = seginfo->frchainP;
10229               frchainP->frch_root = fragP;
10230               frchainP->frch_last = fragP;
10231
10232               fixes = (fixS *) xmalloc (sizeof (fixS) * num_recs);
10233               memset (fixes, 0, sizeof (fixS) * num_recs);
10234
10235               seginfo->fix_root = fixes;
10236               seginfo->fix_tail = &fixes[num_recs - 1];
10237               cur_block = block;
10238               frag_data = &fragP->fr_literal[0];
10239               for (i = 0; i < num_recs; i++)
10240                 {
10241                   fixS *fix = &fixes[i];
10242                   assert (cur_block);
10243
10244                   /* Write the fixup.  */
10245                   if (i != num_recs - 1)
10246                     fix->fx_next = &fixes[i + 1];
10247                   else
10248                     fix->fx_next = NULL;
10249                   fix->fx_size = 4;
10250                   fix->fx_done = 0;
10251                   fix->fx_frag = fragP;
10252                   fix->fx_where = i * 8;
10253                   fix->fx_addsy = section_symbol (cur_block->sec);
10254                   fix->fx_offset = cur_block->offset;
10255                   fix->fx_r_type = BFD_RELOC_32;
10256                   fix->fx_file = "Internal Assembly";
10257                   fix->fx_line = 0;
10258
10259                   /* Write the length.  */
10260                   md_number_to_chars (&frag_data[4 + 8 * i],
10261                                       cur_block->size, 4);
10262                   cur_block = cur_block->next;
10263                 }
10264             }
10265         }
10266     }
10267 }
10268
10269
10270 static void
10271 xtensa_create_xproperty_segments (frag_flags_fn flag_fn,
10272                                   const char *section_name_base,
10273                                   xt_section_type sec_type)
10274 {
10275   segT *seclist;
10276
10277   /* Walk over all of the current segments.
10278      Walk over each fragment.
10279      For each fragment that has instructions,
10280      build an instruction record (append where possible).  */
10281
10282   for (seclist = &stdoutput->sections;
10283        seclist && *seclist;
10284        seclist = &(*seclist)->next)
10285     {
10286       segT sec = *seclist;
10287       flagword flags;
10288
10289       flags = bfd_get_section_flags (stdoutput, sec);
10290       if ((flags & SEC_DEBUGGING)
10291           || !(flags & SEC_ALLOC)
10292           || (flags & SEC_MERGE))
10293         continue;
10294
10295       if (section_has_xproperty (sec, flag_fn))
10296         {
10297           char *property_section_name =
10298             xtensa_get_property_section_name (sec, section_name_base);
10299           segT insn_sec = retrieve_xtensa_section (property_section_name);
10300           segment_info_type *xt_seg_info = retrieve_segment_info (insn_sec);
10301           xtensa_block_info **xt_blocks =
10302             &xt_seg_info->tc_segment_info_data.blocks[sec_type];
10303           /* Walk over all of the frchains here and add new sections.  */
10304           add_xt_prop_frags (sec, insn_sec, xt_blocks, flag_fn);
10305         }
10306     }
10307
10308   /* Now we fill them out....  */
10309
10310   for (seclist = &stdoutput->sections;
10311        seclist && *seclist;
10312        seclist = &(*seclist)->next)
10313     {
10314       segment_info_type *seginfo;
10315       xtensa_block_info *block;
10316       segT sec = *seclist;
10317
10318       seginfo = seg_info (sec);
10319       block = seginfo->tc_segment_info_data.blocks[sec_type];
10320
10321       if (block)
10322         {
10323           xtensa_block_info *cur_block;
10324           /* This is a section with some data.  */
10325           int num_recs = 0;
10326           bfd_size_type rec_size;
10327
10328           for (cur_block = block; cur_block; cur_block = cur_block->next)
10329             num_recs++;
10330
10331           rec_size = num_recs * (8 + 4);
10332           bfd_set_section_size (stdoutput, sec, rec_size);
10333
10334           /* elf_section_data (sec)->this_hdr.sh_entsize = 12; */
10335
10336           /* In order to make this work with the assembler, we have to build
10337              some frags then build the "fixups" for it.  It would be easier to
10338              just set the contents then set the arlents.  */
10339
10340           if (num_recs)
10341             {
10342               /* Allocate a fragment and (unfortunately) leak it.  */
10343               fragS *fragP;
10344               bfd_size_type frag_size;
10345               fixS *fixes;
10346               frchainS *frchainP;
10347               int i;
10348               char *frag_data;
10349
10350               frag_size = sizeof (fragS) + rec_size;
10351               fragP = (fragS *) xmalloc (frag_size);
10352
10353               memset (fragP, 0, frag_size);
10354               fragP->fr_address = 0;
10355               fragP->fr_next = NULL;
10356               fragP->fr_fix = rec_size;
10357               fragP->fr_var = 0;
10358               fragP->fr_type = rs_fill;
10359               /* The rest are zeros.  */
10360
10361               frchainP = seginfo->frchainP;
10362               frchainP->frch_root = fragP;
10363               frchainP->frch_last = fragP;
10364
10365               fixes = (fixS *) xmalloc (sizeof (fixS) * num_recs);
10366               memset (fixes, 0, sizeof (fixS) * num_recs);
10367
10368               seginfo->fix_root = fixes;
10369               seginfo->fix_tail = &fixes[num_recs - 1];
10370               cur_block = block;
10371               frag_data = &fragP->fr_literal[0];
10372               for (i = 0; i < num_recs; i++)
10373                 {
10374                   fixS *fix = &fixes[i];
10375                   assert (cur_block);
10376
10377                   /* Write the fixup.  */
10378                   if (i != num_recs - 1)
10379                     fix->fx_next = &fixes[i + 1];
10380                   else
10381                     fix->fx_next = NULL;
10382                   fix->fx_size = 4;
10383                   fix->fx_done = 0;
10384                   fix->fx_frag = fragP;
10385                   fix->fx_where = i * (8 + 4);
10386                   fix->fx_addsy = section_symbol (cur_block->sec);
10387                   fix->fx_offset = cur_block->offset;
10388                   fix->fx_r_type = BFD_RELOC_32;
10389                   fix->fx_file = "Internal Assembly";
10390                   fix->fx_line = 0;
10391
10392                   /* Write the length.  */
10393                   md_number_to_chars (&frag_data[4 + (8+4) * i],
10394                                       cur_block->size, 4);
10395                   md_number_to_chars (&frag_data[8 + (8+4) * i],
10396                                       frag_flags_to_number (&cur_block->flags),
10397                                       4);
10398                   cur_block = cur_block->next;
10399                 }
10400             }
10401         }
10402     }
10403 }
10404
10405
10406 static segment_info_type *
10407 retrieve_segment_info (segT seg)
10408 {
10409   segment_info_type *seginfo;
10410   seginfo = (segment_info_type *) bfd_get_section_userdata (stdoutput, seg);
10411   if (!seginfo)
10412     {
10413       frchainS *frchainP;
10414
10415       seginfo = (segment_info_type *) xmalloc (sizeof (*seginfo));
10416       memset ((void *) seginfo, 0, sizeof (*seginfo));
10417       seginfo->fix_root = NULL;
10418       seginfo->fix_tail = NULL;
10419       seginfo->bfd_section = seg;
10420       seginfo->sym = 0;
10421       /* We will not be dealing with these, only our special ones.  */
10422       bfd_set_section_userdata (stdoutput, seg, (void *) seginfo);
10423
10424       frchainP = (frchainS *) xmalloc (sizeof (frchainS));
10425       frchainP->frch_root = NULL;
10426       frchainP->frch_last = NULL;
10427       frchainP->frch_next = NULL;
10428       frchainP->frch_seg = seg;
10429       frchainP->frch_subseg = 0;
10430       frchainP->fix_root = NULL;
10431       frchainP->fix_tail = NULL;
10432       /* Do not init the objstack.  */
10433       /* obstack_begin (&frchainP->frch_obstack, chunksize); */
10434       /* frchainP->frch_frag_now = fragP; */
10435       frchainP->frch_frag_now = NULL;
10436
10437       seginfo->frchainP = frchainP;
10438     }
10439
10440   return seginfo;
10441 }
10442
10443
10444 static segT
10445 retrieve_xtensa_section (char *sec_name)
10446 {
10447   bfd *abfd = stdoutput;
10448   flagword flags, out_flags, link_once_flags;
10449   segT s;
10450
10451   flags = bfd_get_section_flags (abfd, now_seg);
10452   link_once_flags = (flags & SEC_LINK_ONCE);
10453   if (link_once_flags)
10454     link_once_flags |= (flags & SEC_LINK_DUPLICATES);
10455   out_flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY | link_once_flags);
10456
10457   s = bfd_make_section_old_way (abfd, sec_name);
10458   if (s == NULL)
10459     as_bad (_("could not create section %s"), sec_name);
10460   if (!bfd_set_section_flags (abfd, s, out_flags))
10461     as_bad (_("invalid flag combination on section %s"), sec_name);
10462
10463   return s;
10464 }
10465
10466
10467 static bfd_boolean
10468 section_has_property (segT sec, frag_predicate property_function)
10469 {
10470   segment_info_type *seginfo = seg_info (sec);
10471   fragS *fragP;
10472
10473   if (seginfo && seginfo->frchainP)
10474     {
10475       for (fragP = seginfo->frchainP->frch_root; fragP; fragP = fragP->fr_next)
10476         {
10477           if (property_function (fragP)
10478               && (fragP->fr_type != rs_fill || fragP->fr_fix != 0))
10479             return TRUE;
10480         }
10481     }
10482   return FALSE;
10483 }
10484
10485
10486 static bfd_boolean
10487 section_has_xproperty (segT sec, frag_flags_fn property_function)
10488 {
10489   segment_info_type *seginfo = seg_info (sec);
10490   fragS *fragP;
10491
10492   if (seginfo && seginfo->frchainP)
10493     {
10494       for (fragP = seginfo->frchainP->frch_root; fragP; fragP = fragP->fr_next)
10495         {
10496           frag_flags prop_flags;
10497           property_function (fragP, &prop_flags);
10498           if (!xtensa_frag_flags_is_empty (&prop_flags))
10499             return TRUE;
10500         }
10501     }
10502   return FALSE;
10503 }
10504
10505
10506 /* Two types of block sections exist right now: literal and insns.  */
10507
10508 static void
10509 add_xt_block_frags (segT sec,
10510                     segT xt_block_sec,
10511                     xtensa_block_info **xt_block,
10512                     frag_predicate property_function,
10513                     frag_predicate end_property_function)
10514 {
10515   segment_info_type *seg_info;
10516   segment_info_type *xt_seg_info;
10517   bfd_vma seg_offset;
10518   fragS *fragP;
10519
10520   xt_seg_info = retrieve_segment_info (xt_block_sec);
10521   seg_info = retrieve_segment_info (sec);
10522
10523   /* Build it if needed.  */
10524   while (*xt_block != NULL)
10525     xt_block = &(*xt_block)->next;
10526   /* We are either at NULL at the beginning or at the end.  */
10527
10528   /* Walk through the frags.  */
10529   seg_offset = 0;
10530
10531   if (seg_info->frchainP)
10532     {
10533       for (fragP = seg_info->frchainP->frch_root;
10534            fragP;
10535            fragP = fragP->fr_next)
10536         {
10537           if (property_function (fragP)
10538               && (fragP->fr_type != rs_fill || fragP->fr_fix != 0))
10539             {
10540               if (*xt_block != NULL)
10541                 {
10542                   if ((*xt_block)->offset + (*xt_block)->size
10543                       == fragP->fr_address)
10544                     (*xt_block)->size += fragP->fr_fix;
10545                   else
10546                     xt_block = &((*xt_block)->next);
10547                 }
10548               if (*xt_block == NULL)
10549                 {
10550                   xtensa_block_info *new_block = (xtensa_block_info *)
10551                     xmalloc (sizeof (xtensa_block_info));
10552                   new_block->sec = sec;
10553                   new_block->offset = fragP->fr_address;
10554                   new_block->size = fragP->fr_fix;
10555                   new_block->next = NULL;
10556                   xtensa_frag_flags_init (&new_block->flags);
10557                   *xt_block = new_block;
10558                 }
10559               if (end_property_function
10560                   && end_property_function (fragP))
10561                 {
10562                   xt_block = &((*xt_block)->next);
10563                 }
10564             }
10565         }
10566     }
10567 }
10568
10569
10570 /* Break the encapsulation of add_xt_prop_frags here.  */
10571
10572 static bfd_boolean
10573 xtensa_frag_flags_is_empty (const frag_flags *prop_flags)
10574 {
10575   if (prop_flags->is_literal
10576       || prop_flags->is_insn
10577       || prop_flags->is_data
10578       || prop_flags->is_unreachable)
10579     return FALSE;
10580   return TRUE;
10581 }
10582
10583
10584 static void
10585 xtensa_frag_flags_init (frag_flags *prop_flags)
10586 {
10587   memset (prop_flags, 0, sizeof (frag_flags));
10588 }
10589
10590
10591 static void
10592 get_frag_property_flags (const fragS *fragP, frag_flags *prop_flags)
10593 {
10594   xtensa_frag_flags_init (prop_flags);
10595   if (fragP->tc_frag_data.is_literal)
10596     prop_flags->is_literal = TRUE;
10597   if (fragP->tc_frag_data.is_unreachable)
10598     prop_flags->is_unreachable = TRUE;
10599   else if (fragP->tc_frag_data.is_insn)
10600     {
10601       prop_flags->is_insn = TRUE;
10602       if (fragP->tc_frag_data.is_loop_target)
10603         prop_flags->insn.is_loop_target = TRUE;
10604       if (fragP->tc_frag_data.is_branch_target)
10605         prop_flags->insn.is_branch_target = TRUE;
10606       if (fragP->tc_frag_data.is_specific_opcode
10607           || fragP->tc_frag_data.is_no_transform)
10608         prop_flags->insn.is_no_transform = TRUE;
10609       if (fragP->tc_frag_data.is_no_density)
10610         prop_flags->insn.is_no_density = TRUE;
10611       if (fragP->tc_frag_data.use_absolute_literals)
10612         prop_flags->insn.is_abslit = TRUE;
10613     }
10614   if (fragP->tc_frag_data.is_align)
10615     {
10616       prop_flags->is_align = TRUE;
10617       prop_flags->alignment = fragP->tc_frag_data.alignment;
10618       if (xtensa_frag_flags_is_empty (prop_flags))
10619         prop_flags->is_data = TRUE;
10620     }
10621 }
10622
10623
10624 static bfd_vma
10625 frag_flags_to_number (const frag_flags *prop_flags)
10626 {
10627   bfd_vma num = 0;
10628   if (prop_flags->is_literal)
10629     num |= XTENSA_PROP_LITERAL;
10630   if (prop_flags->is_insn)
10631     num |= XTENSA_PROP_INSN;
10632   if (prop_flags->is_data)
10633     num |= XTENSA_PROP_DATA;
10634   if (prop_flags->is_unreachable)
10635     num |= XTENSA_PROP_UNREACHABLE;
10636   if (prop_flags->insn.is_loop_target)
10637     num |= XTENSA_PROP_INSN_LOOP_TARGET;
10638   if (prop_flags->insn.is_branch_target)
10639     {
10640       num |= XTENSA_PROP_INSN_BRANCH_TARGET;
10641       num = SET_XTENSA_PROP_BT_ALIGN (num, prop_flags->insn.bt_align_priority);
10642     }
10643
10644   if (prop_flags->insn.is_no_density)
10645     num |= XTENSA_PROP_INSN_NO_DENSITY;
10646   if (prop_flags->insn.is_no_transform)
10647     num |= XTENSA_PROP_INSN_NO_TRANSFORM;
10648   if (prop_flags->insn.is_no_reorder)
10649     num |= XTENSA_PROP_INSN_NO_REORDER;
10650   if (prop_flags->insn.is_abslit)
10651     num |= XTENSA_PROP_INSN_ABSLIT;
10652
10653   if (prop_flags->is_align)
10654     {
10655       num |= XTENSA_PROP_ALIGN;
10656       num = SET_XTENSA_PROP_ALIGNMENT (num, prop_flags->alignment);
10657     }
10658
10659   return num;
10660 }
10661
10662
10663 static bfd_boolean
10664 xtensa_frag_flags_combinable (const frag_flags *prop_flags_1,
10665                               const frag_flags *prop_flags_2)
10666 {
10667   /* Cannot combine with an end marker.  */
10668
10669   if (prop_flags_1->is_literal != prop_flags_2->is_literal)
10670     return FALSE;
10671   if (prop_flags_1->is_insn != prop_flags_2->is_insn)
10672     return FALSE;
10673   if (prop_flags_1->is_data != prop_flags_2->is_data)
10674     return FALSE;
10675
10676   if (prop_flags_1->is_insn)
10677     {
10678       /* Properties of the beginning of the frag.  */
10679       if (prop_flags_2->insn.is_loop_target)
10680         return FALSE;
10681       if (prop_flags_2->insn.is_branch_target)
10682         return FALSE;
10683       if (prop_flags_1->insn.is_no_density !=
10684           prop_flags_2->insn.is_no_density)
10685         return FALSE;
10686       if (prop_flags_1->insn.is_no_transform !=
10687           prop_flags_2->insn.is_no_transform)
10688         return FALSE;
10689       if (prop_flags_1->insn.is_no_reorder !=
10690           prop_flags_2->insn.is_no_reorder)
10691         return FALSE;
10692       if (prop_flags_1->insn.is_abslit !=
10693           prop_flags_2->insn.is_abslit)
10694         return FALSE;
10695     }
10696
10697   if (prop_flags_1->is_align)
10698     return FALSE;
10699
10700   return TRUE;
10701 }
10702
10703
10704 static bfd_vma
10705 xt_block_aligned_size (const xtensa_block_info *xt_block)
10706 {
10707   bfd_vma end_addr;
10708   unsigned align_bits;
10709
10710   if (!xt_block->flags.is_align)
10711     return xt_block->size;
10712
10713   end_addr = xt_block->offset + xt_block->size;
10714   align_bits = xt_block->flags.alignment;
10715   end_addr = ((end_addr + ((1 << align_bits) -1)) >> align_bits) << align_bits;
10716   return end_addr - xt_block->offset;
10717 }
10718
10719
10720 static bfd_boolean
10721 xtensa_xt_block_combine (xtensa_block_info *xt_block,
10722                          const xtensa_block_info *xt_block_2)
10723 {
10724   if (xt_block->sec != xt_block_2->sec)
10725     return FALSE;
10726   if (xt_block->offset + xt_block_aligned_size (xt_block)
10727       != xt_block_2->offset)
10728     return FALSE;
10729
10730   if (xt_block_2->size == 0
10731       && (!xt_block_2->flags.is_unreachable
10732           || xt_block->flags.is_unreachable))
10733     {
10734       if (xt_block_2->flags.is_align
10735           && xt_block->flags.is_align)
10736         {
10737           /* Nothing needed.  */
10738           if (xt_block->flags.alignment >= xt_block_2->flags.alignment)
10739             return TRUE;
10740         }
10741       else
10742         {
10743           if (xt_block_2->flags.is_align)
10744             {
10745               /* Push alignment to previous entry.  */
10746               xt_block->flags.is_align = xt_block_2->flags.is_align;
10747               xt_block->flags.alignment = xt_block_2->flags.alignment;
10748             }
10749           return TRUE;
10750         }
10751     }
10752   if (!xtensa_frag_flags_combinable (&xt_block->flags,
10753                                      &xt_block_2->flags))
10754     return FALSE;
10755
10756   xt_block->size += xt_block_2->size;
10757
10758   if (xt_block_2->flags.is_align)
10759     {
10760       xt_block->flags.is_align = TRUE;
10761       xt_block->flags.alignment = xt_block_2->flags.alignment;
10762     }
10763
10764   return TRUE;
10765 }
10766
10767
10768 static void
10769 add_xt_prop_frags (segT sec,
10770                    segT xt_block_sec,
10771                    xtensa_block_info **xt_block,
10772                    frag_flags_fn property_function)
10773 {
10774   segment_info_type *seg_info;
10775   segment_info_type *xt_seg_info;
10776   bfd_vma seg_offset;
10777   fragS *fragP;
10778
10779   xt_seg_info = retrieve_segment_info (xt_block_sec);
10780   seg_info = retrieve_segment_info (sec);
10781   /* Build it if needed.  */
10782   while (*xt_block != NULL)
10783     {
10784       xt_block = &(*xt_block)->next;
10785     }
10786   /* We are either at NULL at the beginning or at the end.  */
10787
10788   /* Walk through the frags.  */
10789   seg_offset = 0;
10790
10791   if (seg_info->frchainP)
10792     {
10793       for (fragP = seg_info->frchainP->frch_root; fragP;
10794            fragP = fragP->fr_next)
10795         {
10796           xtensa_block_info tmp_block;
10797           tmp_block.sec = sec;
10798           tmp_block.offset = fragP->fr_address;
10799           tmp_block.size = fragP->fr_fix;
10800           tmp_block.next = NULL;
10801           property_function (fragP, &tmp_block.flags);
10802
10803           if (!xtensa_frag_flags_is_empty (&tmp_block.flags))
10804             /* && fragP->fr_fix != 0) */
10805             {
10806               if ((*xt_block) == NULL
10807                   || !xtensa_xt_block_combine (*xt_block, &tmp_block))
10808                 {
10809                   xtensa_block_info *new_block;
10810                   if ((*xt_block) != NULL)
10811                     xt_block = &(*xt_block)->next;
10812                   new_block = (xtensa_block_info *)
10813                     xmalloc (sizeof (xtensa_block_info));
10814                   *new_block = tmp_block;
10815                   *xt_block = new_block;
10816                 }
10817             }
10818         }
10819     }
10820 }
10821
10822 \f
10823 /* op_placement_info_table */
10824
10825 /* op_placement_info makes it easier to determine which
10826    ops can go in which slots.  */
10827
10828 static void
10829 init_op_placement_info_table (void)
10830 {
10831   xtensa_isa isa = xtensa_default_isa;
10832   xtensa_insnbuf ibuf = xtensa_insnbuf_alloc (isa);
10833   xtensa_opcode opcode;
10834   xtensa_format fmt;
10835   int slot;
10836   int num_opcodes = xtensa_isa_num_opcodes (isa);
10837
10838   op_placement_table = (op_placement_info_table)
10839     xmalloc (sizeof (op_placement_info) * num_opcodes);
10840   assert (xtensa_isa_num_formats (isa) < MAX_FORMATS);
10841
10842   for (opcode = 0; opcode < num_opcodes; opcode++)
10843     {
10844       op_placement_info *opi = &op_placement_table[opcode];
10845       /* FIXME: Make tinsn allocation dynamic.  */
10846       if (xtensa_opcode_num_operands (isa, opcode) >= MAX_INSN_ARGS)
10847         as_fatal (_("too many operands in instruction"));
10848       opi->single = XTENSA_UNDEFINED;
10849       opi->single_size = 0;
10850       opi->widest = XTENSA_UNDEFINED;
10851       opi->widest_size = 0;
10852       opi->narrowest = XTENSA_UNDEFINED;
10853       opi->narrowest_size = 0x7F;
10854       opi->formats = 0;
10855       opi->num_formats = 0;
10856       opi->issuef = 0;
10857       for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
10858         {
10859           opi->slots[fmt] = 0;
10860           for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
10861             {
10862               if (xtensa_opcode_encode (isa, fmt, slot, ibuf, opcode) == 0)
10863                 {
10864                   int fmt_length = xtensa_format_length (isa, fmt);
10865                   opi->issuef++;
10866                   set_bit (fmt, opi->formats);
10867                   set_bit (slot, opi->slots[fmt]);
10868                   /* opi->slot_count[fmt]++; */
10869                   if (fmt_length < opi->narrowest_size)
10870                     {
10871                       opi->narrowest = fmt;
10872                       opi->narrowest_size = fmt_length;
10873                     }
10874                   if (fmt_length > opi->widest_size)
10875                     {
10876                       opi->widest = fmt;
10877                       opi->widest_size = fmt_length;
10878                     }
10879                   if (xtensa_format_num_slots (isa, fmt) == 1)
10880                     {
10881                       if (opi->single_size == 0
10882                           || fmt_length < opi->single_size)
10883                         {
10884                           opi->single = fmt;
10885                           opi->single_size = fmt_length;
10886                         }
10887                     }
10888                 }
10889             }
10890           if (opi->formats)
10891             opi->num_formats++;
10892         }
10893     }
10894   xtensa_insnbuf_free (isa, ibuf);
10895 }
10896
10897
10898 bfd_boolean
10899 opcode_fits_format_slot (xtensa_opcode opcode, xtensa_format fmt, int slot)
10900 {
10901   return bit_is_set (slot, op_placement_table[opcode].slots[fmt]);
10902 }
10903
10904
10905 /* If the opcode is available in a single slot format, return its size.  */
10906
10907 static int
10908 xg_get_single_size (xtensa_opcode opcode)
10909 {
10910   assert (op_placement_table[opcode].single != XTENSA_UNDEFINED);
10911   return op_placement_table[opcode].single_size;
10912 }
10913
10914
10915 static xtensa_format
10916 xg_get_single_format (xtensa_opcode opcode)
10917 {
10918   return op_placement_table[opcode].single;
10919 }
10920
10921 \f
10922 /* Instruction Stack Functions (from "xtensa-istack.h").  */
10923
10924 void
10925 istack_init (IStack *stack)
10926 {
10927   memset (stack, 0, sizeof (IStack));
10928   stack->ninsn = 0;
10929 }
10930
10931
10932 bfd_boolean
10933 istack_empty (IStack *stack)
10934 {
10935   return (stack->ninsn == 0);
10936 }
10937
10938
10939 bfd_boolean
10940 istack_full (IStack *stack)
10941 {
10942   return (stack->ninsn == MAX_ISTACK);
10943 }
10944
10945
10946 /* Return a pointer to the top IStack entry.
10947    It is an error to call this if istack_empty () is TRUE. */
10948
10949 TInsn *
10950 istack_top (IStack *stack)
10951 {
10952   int rec = stack->ninsn - 1;
10953   assert (!istack_empty (stack));
10954   return &stack->insn[rec];
10955 }
10956
10957
10958 /* Add a new TInsn to an IStack.
10959    It is an error to call this if istack_full () is TRUE.  */
10960
10961 void
10962 istack_push (IStack *stack, TInsn *insn)
10963 {
10964   int rec = stack->ninsn;
10965   assert (!istack_full (stack));
10966   stack->insn[rec] = *insn;
10967   stack->ninsn++;
10968 }
10969
10970
10971 /* Clear space for the next TInsn on the IStack and return a pointer
10972    to it.  It is an error to call this if istack_full () is TRUE.  */
10973
10974 TInsn *
10975 istack_push_space (IStack *stack)
10976 {
10977   int rec = stack->ninsn;
10978   TInsn *insn;
10979   assert (!istack_full (stack));
10980   insn = &stack->insn[rec];
10981   memset (insn, 0, sizeof (TInsn));
10982   stack->ninsn++;
10983   return insn;
10984 }
10985
10986
10987 /* Remove the last pushed instruction.  It is an error to call this if
10988    istack_empty () returns TRUE.  */
10989
10990 void
10991 istack_pop (IStack *stack)
10992 {
10993   int rec = stack->ninsn - 1;
10994   assert (!istack_empty (stack));
10995   stack->ninsn--;
10996   memset (&stack->insn[rec], 0, sizeof (TInsn));
10997 }
10998
10999 \f
11000 /* TInsn functions.  */
11001
11002 void
11003 tinsn_init (TInsn *dst)
11004 {
11005   memset (dst, 0, sizeof (TInsn));
11006 }
11007
11008
11009 /* Get the ``num''th token of the TInsn.
11010    It is illegal to call this if num > insn->ntoks.  */
11011
11012 expressionS *
11013 tinsn_get_tok (TInsn *insn, int num)
11014 {
11015   assert (num < insn->ntok);
11016   return &insn->tok[num];
11017 }
11018
11019
11020 /* Return TRUE if ANY of the operands in the insn are symbolic.  */
11021
11022 static bfd_boolean
11023 tinsn_has_symbolic_operands (const TInsn *insn)
11024 {
11025   int i;
11026   int n = insn->ntok;
11027
11028   assert (insn->insn_type == ITYPE_INSN);
11029
11030   for (i = 0; i < n; ++i)
11031     {
11032       switch (insn->tok[i].X_op)
11033         {
11034         case O_register:
11035         case O_constant:
11036           break;
11037         default:
11038           return TRUE;
11039         }
11040     }
11041   return FALSE;
11042 }
11043
11044
11045 bfd_boolean
11046 tinsn_has_invalid_symbolic_operands (const TInsn *insn)
11047 {
11048   xtensa_isa isa = xtensa_default_isa;
11049   int i;
11050   int n = insn->ntok;
11051
11052   assert (insn->insn_type == ITYPE_INSN);
11053
11054   for (i = 0; i < n; ++i)
11055     {
11056       switch (insn->tok[i].X_op)
11057         {
11058         case O_register:
11059         case O_constant:
11060           break;
11061         case O_big:
11062         case O_illegal:
11063         case O_absent:
11064           /* Errors for these types are caught later.  */
11065           break;
11066         case O_hi16:
11067         case O_lo16:
11068         default:
11069           /* Symbolic immediates are only allowed on the last immediate
11070              operand.  At this time, CONST16 is the only opcode where we
11071              support non-PC-relative relocations.  (It isn't necessary
11072              to complain about non-PC-relative relocations here, but
11073              otherwise, no error is reported until the relocations are
11074              generated, and the assembler won't get that far if there
11075              are any other errors.  It's nice to see all the problems
11076              at once.)  */
11077           if (i != get_relaxable_immed (insn->opcode)
11078               || (xtensa_operand_is_PCrelative (isa, insn->opcode, i) != 1
11079                   && insn->opcode != xtensa_const16_opcode))
11080             {
11081               as_bad (_("invalid symbolic operand %d on '%s'"),
11082                       i, xtensa_opcode_name (isa, insn->opcode));
11083               return TRUE;
11084             }
11085         }
11086     }
11087   return FALSE;
11088 }
11089
11090
11091 /* For assembly code with complex expressions (e.g. subtraction),
11092    we have to build them in the literal pool so that
11093    their results are calculated correctly after relaxation.
11094    The relaxation only handles expressions that
11095    boil down to SYMBOL + OFFSET.  */
11096
11097 static bfd_boolean
11098 tinsn_has_complex_operands (const TInsn *insn)
11099 {
11100   int i;
11101   int n = insn->ntok;
11102   assert (insn->insn_type == ITYPE_INSN);
11103   for (i = 0; i < n; ++i)
11104     {
11105       switch (insn->tok[i].X_op)
11106         {
11107         case O_register:
11108         case O_constant:
11109         case O_symbol:
11110         case O_lo16:
11111         case O_hi16:
11112           break;
11113         default:
11114           return TRUE;
11115         }
11116     }
11117   return FALSE;
11118 }
11119
11120
11121 /* Convert the constant operands in the tinsn to insnbuf.
11122    Return TRUE if there is a symbol in the immediate field.
11123
11124    Before this is called,
11125    1) the number of operands are correct
11126    2) the tinsn is a ITYPE_INSN
11127    3) ONLY the relaxable_ is built
11128    4) All operands are O_constant, O_symbol.  All constants fit
11129    The return value tells whether there are any remaining O_symbols.  */
11130
11131 static bfd_boolean
11132 tinsn_to_insnbuf (TInsn *tinsn, xtensa_insnbuf insnbuf)
11133 {
11134   static xtensa_insnbuf slotbuf = 0;
11135   xtensa_isa isa = xtensa_default_isa;
11136   xtensa_opcode opcode = tinsn->opcode;
11137   xtensa_format fmt = xg_get_single_format (opcode);
11138   bfd_boolean has_fixup = FALSE;
11139   int noperands = xtensa_opcode_num_operands (isa, opcode);
11140   int i;
11141   uint32 opnd_value;
11142   char *file_name;
11143   unsigned line;
11144
11145   if (!slotbuf)
11146     slotbuf = xtensa_insnbuf_alloc (isa);
11147
11148   assert (tinsn->insn_type == ITYPE_INSN);
11149   if (noperands != tinsn->ntok)
11150     as_fatal (_("operand number mismatch"));
11151
11152   if (xtensa_opcode_encode (isa, fmt, 0, slotbuf, opcode))
11153     as_fatal (_("cannot encode opcode"));
11154
11155   for (i = 0; i < noperands; ++i)
11156     {
11157       expressionS *expr = &tinsn->tok[i];
11158       switch (expr->X_op)
11159         {
11160         case O_register:
11161           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11162             break;
11163           /* The register number has already been checked in
11164              expression_maybe_register, so we don't need to check here.  */
11165           opnd_value = expr->X_add_number;
11166           (void) xtensa_operand_encode (isa, opcode, i, &opnd_value);
11167           xtensa_operand_set_field (isa, opcode, i, fmt, 0,
11168                                     slotbuf, opnd_value);
11169           break;
11170
11171         case O_constant:
11172           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11173             break;
11174           as_where (&file_name, &line);
11175           /* It is a constant and we called this function,
11176              then we have to try to fit it.  */
11177           xtensa_insnbuf_set_operand (slotbuf, fmt, 0, opcode, i,
11178                                       expr->X_add_number, file_name, line);
11179           break;
11180
11181         default:
11182           has_fixup = TRUE;
11183           break;
11184         }
11185     }
11186
11187   xtensa_format_encode (isa, fmt, insnbuf);
11188   xtensa_format_set_slot (isa, fmt, 0, insnbuf, slotbuf);
11189
11190   return has_fixup;
11191 }
11192
11193
11194 /* Convert the constant operands in the tinsn to slotbuf.
11195    Return TRUE if there is a symbol in the immediate field.
11196    (Eventually this should replace tinsn_to_insnbuf.)  */
11197
11198 /* Before this is called,
11199    1) the number of operands are correct
11200    2) the tinsn is a ITYPE_INSN
11201    3) ONLY the relaxable_ is built
11202    4) All operands are
11203        O_constant, O_symbol
11204       All constants fit
11205
11206    The return value tells whether there are any remaining O_symbols.  */
11207
11208 static bfd_boolean
11209 tinsn_to_slotbuf (xtensa_format fmt,
11210                   int slot,
11211                   TInsn *tinsn,
11212                   xtensa_insnbuf slotbuf)
11213 {
11214   xtensa_isa isa = xtensa_default_isa;
11215   xtensa_opcode opcode = tinsn->opcode;
11216   bfd_boolean has_fixup = FALSE;
11217   int noperands = xtensa_opcode_num_operands (isa, opcode);
11218   int i;
11219
11220   *((int *) &slotbuf[0]) = 0;
11221   *((int *) &slotbuf[1]) = 0;
11222   assert (tinsn->insn_type == ITYPE_INSN);
11223   if (noperands != tinsn->ntok)
11224     as_fatal (_("operand number mismatch"));
11225
11226   if (xtensa_opcode_encode (isa, fmt, slot, slotbuf, opcode))
11227     {
11228       as_bad (_("cannot encode opcode \"%s\" in the given format \"%s\""),
11229               xtensa_opcode_name (isa, opcode), xtensa_format_name (isa, fmt));
11230       return FALSE;
11231     }
11232
11233   for (i = 0; i < noperands; i++)
11234     {
11235       expressionS *expr = &tinsn->tok[i];
11236       int rc;
11237       unsigned line;
11238       char *file_name;
11239       uint32 opnd_value;
11240
11241       switch (expr->X_op)
11242         {
11243         case O_register:
11244           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11245             break;
11246           /* The register number has already been checked in
11247              expression_maybe_register, so we don't need to check here.  */
11248           opnd_value = expr->X_add_number;
11249           (void) xtensa_operand_encode (isa, opcode, i, &opnd_value);
11250           rc = xtensa_operand_set_field (isa, opcode, i, fmt, slot, slotbuf,
11251                                          opnd_value);
11252           if (rc != 0)
11253             as_warn (_("xtensa-isa failure: %s"), xtensa_isa_error_msg (isa));
11254           break;
11255
11256         case O_constant:
11257           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11258             break;
11259           as_where (&file_name, &line);
11260           /* It is a constant and we called this function
11261              then we have to try to fit it.  */
11262           xtensa_insnbuf_set_operand (slotbuf, fmt, slot, opcode, i,
11263                                       expr->X_add_number, file_name, line);
11264           break;
11265
11266         default:
11267           has_fixup = TRUE;
11268           break;
11269         }
11270     }
11271
11272   return has_fixup;
11273 }
11274
11275
11276 /* Check the instruction arguments.  Return TRUE on failure.  */
11277
11278 static bfd_boolean
11279 tinsn_check_arguments (const TInsn *insn)
11280 {
11281   xtensa_isa isa = xtensa_default_isa;
11282   xtensa_opcode opcode = insn->opcode;
11283
11284   if (opcode == XTENSA_UNDEFINED)
11285     {
11286       as_bad (_("invalid opcode"));
11287       return TRUE;
11288     }
11289
11290   if (xtensa_opcode_num_operands (isa, opcode) > insn->ntok)
11291     {
11292       as_bad (_("too few operands"));
11293       return TRUE;
11294     }
11295
11296   if (xtensa_opcode_num_operands (isa, opcode) < insn->ntok)
11297     {
11298       as_bad (_("too many operands"));
11299       return TRUE;
11300     }
11301   return FALSE;
11302 }
11303
11304
11305 /* Load an instruction from its encoded form.  */
11306
11307 static void
11308 tinsn_from_chars (TInsn *tinsn, char *f, int slot)
11309 {
11310   vliw_insn vinsn;
11311
11312   xg_init_vinsn (&vinsn);
11313   vinsn_from_chars (&vinsn, f);
11314
11315   *tinsn = vinsn.slots[slot];
11316   xg_free_vinsn (&vinsn);
11317 }
11318
11319
11320 static void
11321 tinsn_from_insnbuf (TInsn *tinsn,
11322                     xtensa_insnbuf slotbuf,
11323                     xtensa_format fmt,
11324                     int slot)
11325 {
11326   int i;
11327   xtensa_isa isa = xtensa_default_isa;
11328
11329   /* Find the immed.  */
11330   tinsn_init (tinsn);
11331   tinsn->insn_type = ITYPE_INSN;
11332   tinsn->is_specific_opcode = FALSE;    /* must not be specific */
11333   tinsn->opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
11334   tinsn->ntok = xtensa_opcode_num_operands (isa, tinsn->opcode);
11335   for (i = 0; i < tinsn->ntok; i++)
11336     {
11337       set_expr_const (&tinsn->tok[i],
11338                       xtensa_insnbuf_get_operand (slotbuf, fmt, slot,
11339                                                   tinsn->opcode, i));
11340     }
11341 }
11342
11343
11344 /* Read the value of the relaxable immed from the fr_symbol and fr_offset.  */
11345
11346 static void
11347 tinsn_immed_from_frag (TInsn *tinsn, fragS *fragP, int slot)
11348 {
11349   xtensa_opcode opcode = tinsn->opcode;
11350   int opnum;
11351
11352   if (fragP->tc_frag_data.slot_symbols[slot])
11353     {
11354       opnum = get_relaxable_immed (opcode);
11355       assert (opnum >= 0);
11356       if (fragP->tc_frag_data.slot_sub_symbols[slot])
11357         {
11358           set_expr_symbol_offset_diff
11359             (&tinsn->tok[opnum],
11360              fragP->tc_frag_data.slot_symbols[slot],
11361              fragP->tc_frag_data.slot_sub_symbols[slot],
11362              fragP->tc_frag_data.slot_offsets[slot]);
11363         }
11364       else
11365         {
11366           set_expr_symbol_offset
11367             (&tinsn->tok[opnum],
11368              fragP->tc_frag_data.slot_symbols[slot],
11369              fragP->tc_frag_data.slot_offsets[slot]);
11370         }
11371     }
11372 }
11373
11374
11375 static int
11376 get_num_stack_text_bytes (IStack *istack)
11377 {
11378   int i;
11379   int text_bytes = 0;
11380
11381   for (i = 0; i < istack->ninsn; i++)
11382     {
11383       TInsn *tinsn = &istack->insn[i];
11384       if (tinsn->insn_type == ITYPE_INSN)
11385         text_bytes += xg_get_single_size (tinsn->opcode);
11386     }
11387   return text_bytes;
11388 }
11389
11390
11391 static int
11392 get_num_stack_literal_bytes (IStack *istack)
11393 {
11394   int i;
11395   int lit_bytes = 0;
11396
11397   for (i = 0; i < istack->ninsn; i++)
11398     {
11399       TInsn *tinsn = &istack->insn[i];
11400       if (tinsn->insn_type == ITYPE_LITERAL && tinsn->ntok == 1)
11401         lit_bytes += 4;
11402     }
11403   return lit_bytes;
11404 }
11405
11406 \f
11407 /* vliw_insn functions.  */
11408
11409 static void
11410 xg_init_vinsn (vliw_insn *v)
11411 {
11412   int i;
11413   xtensa_isa isa = xtensa_default_isa;
11414
11415   xg_clear_vinsn (v);
11416
11417   v->insnbuf = xtensa_insnbuf_alloc (isa);
11418   if (v->insnbuf == NULL)
11419     as_fatal (_("out of memory"));
11420
11421   for (i = 0; i < MAX_SLOTS; i++)
11422     {
11423       tinsn_init (&v->slots[i]);
11424       v->slots[i].opcode = XTENSA_UNDEFINED;
11425       v->slotbuf[i] = xtensa_insnbuf_alloc (isa);
11426       if (v->slotbuf[i] == NULL)
11427         as_fatal (_("out of memory"));
11428     }
11429 }
11430
11431
11432 static void
11433 xg_clear_vinsn (vliw_insn *v)
11434 {
11435   int i;
11436   v->format = XTENSA_UNDEFINED;
11437   v->num_slots = 0;
11438   v->inside_bundle = FALSE;
11439
11440   if (xt_saved_debug_type != DEBUG_NONE)
11441     debug_type = xt_saved_debug_type;
11442
11443   for (i = 0; i < MAX_SLOTS; i++)
11444     {
11445       memset (&v->slots[i], 0, sizeof (TInsn));
11446       v->slots[i].opcode = XTENSA_UNDEFINED;
11447     }
11448 }
11449
11450
11451 static bfd_boolean
11452 vinsn_has_specific_opcodes (vliw_insn *v)
11453 {
11454   int i;
11455
11456   for (i = 0; i < v->num_slots; i++)
11457     {
11458       if (v->slots[i].is_specific_opcode)
11459         return TRUE;
11460     }
11461   return FALSE;
11462 }
11463
11464
11465 static void
11466 xg_free_vinsn (vliw_insn *v)
11467 {
11468   int i;
11469   xtensa_insnbuf_free (xtensa_default_isa, v->insnbuf);
11470   for (i = 0; i < MAX_SLOTS; i++)
11471     xtensa_insnbuf_free (xtensa_default_isa, v->slotbuf[i]);
11472 }
11473
11474
11475 /* Before this is called, we should have
11476    filled out the following fields:
11477
11478    1) the number of operands for each opcode are correct
11479    2) the tinsn in the slots are ITYPE_INSN
11480    3) ONLY the relaxable_ is built
11481    4) All operands are
11482        O_constant, O_symbol
11483       All constants fit
11484
11485    The return value tells whether there are any remaining O_symbols.  */
11486
11487 static bfd_boolean
11488 vinsn_to_insnbuf (vliw_insn *vinsn,
11489                   char *frag_offset,
11490                   fragS *fragP,
11491                   bfd_boolean record_fixup)
11492 {
11493   xtensa_isa isa = xtensa_default_isa;
11494   xtensa_format fmt = vinsn->format;
11495   xtensa_insnbuf insnbuf = vinsn->insnbuf;
11496   int slot;
11497   bfd_boolean has_fixup = FALSE;
11498
11499   xtensa_format_encode (isa, fmt, insnbuf);
11500
11501   for (slot = 0; slot < vinsn->num_slots; slot++)
11502     {
11503       TInsn *tinsn = &vinsn->slots[slot];
11504       bfd_boolean tinsn_has_fixup =
11505         tinsn_to_slotbuf (vinsn->format, slot, tinsn,
11506                           vinsn->slotbuf[slot]);
11507
11508       xtensa_format_set_slot (isa, fmt, slot,
11509                               insnbuf, vinsn->slotbuf[slot]);
11510       /* tinsn_has_fixup tracks if there is a fixup at all.
11511          record_fixup controls globally.  I.E., we use this
11512          function from several places, some of which are after
11513          fixups have already been recorded.  Finally,
11514          tinsn->record_fixup controls based on the individual ops,
11515          which may or may not need it based on the relaxation
11516          requirements.  */
11517       if (tinsn_has_fixup && record_fixup)
11518         {
11519           int i;
11520           xtensa_opcode opcode = tinsn->opcode;
11521           int noperands = xtensa_opcode_num_operands (isa, opcode);
11522           has_fixup = TRUE;
11523
11524           for (i = 0; i < noperands; i++)
11525             {
11526               expressionS* expr = &tinsn->tok[i];
11527               switch (expr->X_op)
11528                 {
11529                 case O_symbol:
11530                 case O_lo16:
11531                 case O_hi16:
11532                   if (get_relaxable_immed (opcode) == i)
11533                     {
11534                       if (tinsn->record_fix || expr->X_op != O_symbol)
11535                         {
11536                           if (!xg_add_opcode_fix
11537                               (tinsn, i, fmt, slot, expr, fragP,
11538                                frag_offset - fragP->fr_literal))
11539                             as_bad (_("instruction with constant operands does not fit"));
11540                         }
11541                       else
11542                         {
11543                           tinsn->symbol = expr->X_add_symbol;
11544                           tinsn->offset = expr->X_add_number;
11545                         }
11546                     }
11547                   else
11548                     as_bad (_("invalid operand %d on '%s'"),
11549                             i, xtensa_opcode_name (isa, opcode));
11550                   break;
11551
11552                 case O_constant:
11553                 case O_register:
11554                   break;
11555
11556                 case O_subtract:
11557                   if (get_relaxable_immed (opcode) == i)
11558                     {
11559                       if (tinsn->record_fix)
11560                           as_bad (_("invalid subtract operand"));
11561                       else
11562                         {
11563                           tinsn->symbol = expr->X_add_symbol;
11564                           tinsn->sub_symbol = expr->X_op_symbol;
11565                           tinsn->offset = expr->X_add_number;
11566                         }
11567                     }
11568                   else
11569                     as_bad (_("invalid operand %d on '%s'"),
11570                             i, xtensa_opcode_name (isa, opcode));
11571                   break;
11572
11573                 default:
11574                   as_bad (_("invalid expression for operand %d on '%s'"),
11575                           i, xtensa_opcode_name (isa, opcode));
11576                   break;
11577                 }
11578             }
11579         }
11580     }
11581
11582   return has_fixup;
11583 }
11584
11585
11586 static void
11587 vinsn_from_chars (vliw_insn *vinsn, char *f)
11588 {
11589   static xtensa_insnbuf insnbuf = NULL;
11590   static xtensa_insnbuf slotbuf = NULL;
11591   int i;
11592   xtensa_format fmt;
11593   xtensa_isa isa = xtensa_default_isa;
11594
11595   if (!insnbuf)
11596     {
11597       insnbuf = xtensa_insnbuf_alloc (isa);
11598       slotbuf = xtensa_insnbuf_alloc (isa);
11599     }
11600
11601   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) f, 0);
11602   fmt = xtensa_format_decode (isa, insnbuf);
11603   if (fmt == XTENSA_UNDEFINED)
11604     as_fatal (_("cannot decode instruction format"));
11605   vinsn->format = fmt;
11606   vinsn->num_slots = xtensa_format_num_slots (isa, fmt);
11607
11608   for (i = 0; i < vinsn->num_slots; i++)
11609     {
11610       TInsn *tinsn = &vinsn->slots[i];
11611       xtensa_format_get_slot (isa, fmt, i, insnbuf, slotbuf);
11612       tinsn_from_insnbuf (tinsn, slotbuf, fmt, i);
11613     }
11614 }
11615
11616 \f
11617 /* Expression utilities.  */
11618
11619 /* Return TRUE if the expression is an integer constant.  */
11620
11621 bfd_boolean
11622 expr_is_const (const expressionS *s)
11623 {
11624   return (s->X_op == O_constant);
11625 }
11626
11627
11628 /* Get the expression constant.
11629    Calling this is illegal if expr_is_const () returns TRUE.  */
11630
11631 offsetT
11632 get_expr_const (const expressionS *s)
11633 {
11634   assert (expr_is_const (s));
11635   return s->X_add_number;
11636 }
11637
11638
11639 /* Set the expression to a constant value.  */
11640
11641 void
11642 set_expr_const (expressionS *s, offsetT val)
11643 {
11644   s->X_op = O_constant;
11645   s->X_add_number = val;
11646   s->X_add_symbol = NULL;
11647   s->X_op_symbol = NULL;
11648 }
11649
11650
11651 bfd_boolean
11652 expr_is_register (const expressionS *s)
11653 {
11654   return (s->X_op == O_register);
11655 }
11656
11657
11658 /* Get the expression constant.
11659    Calling this is illegal if expr_is_const () returns TRUE.  */
11660
11661 offsetT
11662 get_expr_register (const expressionS *s)
11663 {
11664   assert (expr_is_register (s));
11665   return s->X_add_number;
11666 }
11667
11668
11669 /* Set the expression to a symbol + constant offset.  */
11670
11671 void
11672 set_expr_symbol_offset (expressionS *s, symbolS *sym, offsetT offset)
11673 {
11674   s->X_op = O_symbol;
11675   s->X_add_symbol = sym;
11676   s->X_op_symbol = NULL;        /* unused */
11677   s->X_add_number = offset;
11678 }
11679
11680
11681 /* Set the expression to symbol - minus_sym + offset.  */
11682
11683 static void
11684 set_expr_symbol_offset_diff (expressionS *s,
11685                              symbolS *sym,
11686                              symbolS *minus_sym,
11687                              offsetT offset)
11688 {
11689   s->X_op = O_subtract;
11690   s->X_add_symbol = sym;
11691   s->X_op_symbol = minus_sym;   /* unused */
11692   s->X_add_number = offset;
11693 }
11694
11695
11696 /* Return TRUE if the two expressions are equal.  */
11697
11698 bfd_boolean
11699 expr_is_equal (expressionS *s1, expressionS *s2)
11700 {
11701   if (s1->X_op != s2->X_op)
11702     return FALSE;
11703   if (s1->X_add_symbol != s2->X_add_symbol)
11704     return FALSE;
11705   if (s1->X_op_symbol != s2->X_op_symbol)
11706     return FALSE;
11707   if (s1->X_add_number != s2->X_add_number)
11708     return FALSE;
11709   return TRUE;
11710 }
11711
11712
11713 static void
11714 copy_expr (expressionS *dst, const expressionS *src)
11715 {
11716   memcpy (dst, src, sizeof (expressionS));
11717 }
11718
11719 \f
11720 /* Support for the "--rename-section" option.  */
11721
11722 struct rename_section_struct
11723 {
11724   char *old_name;
11725   char *new_name;
11726   struct rename_section_struct *next;
11727 };
11728
11729 static struct rename_section_struct *section_rename;
11730
11731
11732 /* Parse the string "oldname=new_name(:oldname2=new_name2)*" and add
11733    entries to the section_rename list.  Note: Specifying multiple
11734    renamings separated by colons is not documented and is retained only
11735    for backward compatibility.  */
11736
11737 static void
11738 build_section_rename (const char *arg)
11739 {
11740   struct rename_section_struct *r;
11741   char *this_arg = NULL;
11742   char *next_arg = NULL;
11743
11744   for (this_arg = xstrdup (arg); this_arg != NULL; this_arg = next_arg)
11745     {
11746       char *old_name, *new_name;
11747
11748       if (this_arg)
11749         {
11750           next_arg = strchr (this_arg, ':');
11751           if (next_arg)
11752             {
11753               *next_arg = '\0';
11754               next_arg++;
11755             }
11756         }
11757
11758       old_name = this_arg;
11759       new_name = strchr (this_arg, '=');
11760
11761       if (*old_name == '\0')
11762         {
11763           as_warn (_("ignoring extra '-rename-section' delimiter ':'"));
11764           continue;
11765         }
11766       if (!new_name || new_name[1] == '\0')
11767         {
11768           as_warn (_("ignoring invalid '-rename-section' specification: '%s'"),
11769                    old_name);
11770           continue;
11771         }
11772       *new_name = '\0';
11773       new_name++;
11774
11775       /* Check for invalid section renaming.  */
11776       for (r = section_rename; r != NULL; r = r->next)
11777         {
11778           if (strcmp (r->old_name, old_name) == 0)
11779             as_bad (_("section %s renamed multiple times"), old_name);
11780           if (strcmp (r->new_name, new_name) == 0)
11781             as_bad (_("multiple sections remapped to output section %s"),
11782                     new_name);
11783         }
11784
11785       /* Now add it.  */
11786       r = (struct rename_section_struct *)
11787         xmalloc (sizeof (struct rename_section_struct));
11788       r->old_name = xstrdup (old_name);
11789       r->new_name = xstrdup (new_name);
11790       r->next = section_rename;
11791       section_rename = r;
11792     }
11793 }
11794
11795
11796 char *
11797 xtensa_section_rename (char *name)
11798 {
11799   struct rename_section_struct *r = section_rename;
11800
11801   for (r = section_rename; r != NULL; r = r->next)
11802     {
11803       if (strcmp (r->old_name, name) == 0)
11804         return r->new_name;
11805     }
11806
11807   return name;
11808 }