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   dwarf2_emit_label (sym);
5088 }
5089
5090
5091 /* tc_unrecognized_line hook */
5092
5093 int
5094 xtensa_unrecognized_line (int ch)
5095 {
5096   switch (ch)
5097     {
5098     case '{' :
5099       if (cur_vinsn.inside_bundle == 0)
5100         {
5101           /* PR8110: Cannot emit line number info inside a FLIX bundle
5102              when using --gstabs.  Temporarily disable debug info.  */
5103           generate_lineno_debug ();
5104           if (debug_type == DEBUG_STABS)
5105             {
5106               xt_saved_debug_type = debug_type;
5107               debug_type = DEBUG_NONE;
5108             }
5109
5110           cur_vinsn.inside_bundle = 1;
5111         }
5112       else
5113         {
5114           as_bad (_("extra opening brace"));
5115           return 0;
5116         }
5117       break;
5118
5119     case '}' :
5120       if (cur_vinsn.inside_bundle)
5121         finish_vinsn (&cur_vinsn);
5122       else
5123         {
5124           as_bad (_("extra closing brace"));
5125           return 0;
5126         }
5127       break;
5128     default:
5129       as_bad (_("syntax error"));
5130       return 0;
5131     }
5132   return 1;
5133 }
5134
5135
5136 /* md_flush_pending_output hook */
5137
5138 void
5139 xtensa_flush_pending_output (void)
5140 {
5141   if (cur_vinsn.inside_bundle)
5142     as_bad (_("missing closing brace"));
5143
5144   /* If there is a non-zero instruction fragment, close it.  */
5145   if (frag_now_fix () != 0 && frag_now->tc_frag_data.is_insn)
5146     {
5147       frag_wane (frag_now);
5148       frag_new (0);
5149       xtensa_set_frag_assembly_state (frag_now);
5150     }
5151   frag_now->tc_frag_data.is_insn = FALSE;
5152
5153   xtensa_clear_insn_labels ();
5154 }
5155
5156
5157 /* We had an error while parsing an instruction.  The string might look
5158    like this: "insn arg1, arg2 }".  If so, we need to see the closing
5159    brace and reset some fields.  Otherwise, the vinsn never gets closed
5160    and the num_slots field will grow past the end of the array of slots,
5161    and bad things happen.  */
5162
5163 static void
5164 error_reset_cur_vinsn (void)
5165 {
5166   if (cur_vinsn.inside_bundle)
5167     {
5168       if (*input_line_pointer == '}'
5169           || *(input_line_pointer - 1) == '}'
5170           || *(input_line_pointer - 2) == '}')
5171         xg_clear_vinsn (&cur_vinsn);
5172     }
5173 }
5174
5175
5176 void
5177 md_assemble (char *str)
5178 {
5179   xtensa_isa isa = xtensa_default_isa;
5180   char *opname;
5181   unsigned opnamelen;
5182   bfd_boolean has_underbar = FALSE;
5183   char *arg_strings[MAX_INSN_ARGS];
5184   int num_args;
5185   TInsn orig_insn;              /* Original instruction from the input.  */
5186
5187   tinsn_init (&orig_insn);
5188
5189   /* Split off the opcode.  */
5190   opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/0123456789.");
5191   opname = xmalloc (opnamelen + 1);
5192   memcpy (opname, str, opnamelen);
5193   opname[opnamelen] = '\0';
5194
5195   num_args = tokenize_arguments (arg_strings, str + opnamelen);
5196   if (num_args == -1)
5197     {
5198       as_bad (_("syntax error"));
5199       return;
5200     }
5201
5202   if (xg_translate_idioms (&opname, &num_args, arg_strings))
5203     return;
5204
5205   /* Check for an underbar prefix.  */
5206   if (*opname == '_')
5207     {
5208       has_underbar = TRUE;
5209       opname += 1;
5210     }
5211
5212   orig_insn.insn_type = ITYPE_INSN;
5213   orig_insn.ntok = 0;
5214   orig_insn.is_specific_opcode = (has_underbar || !use_transform ());
5215
5216   orig_insn.opcode = xtensa_opcode_lookup (isa, opname);
5217   if (orig_insn.opcode == XTENSA_UNDEFINED)
5218     {
5219       xtensa_format fmt = xtensa_format_lookup (isa, opname);
5220       if (fmt == XTENSA_UNDEFINED)
5221         {
5222           as_bad (_("unknown opcode or format name '%s'"), opname);
5223           error_reset_cur_vinsn ();
5224           return;
5225         }
5226       if (!cur_vinsn.inside_bundle)
5227         {
5228           as_bad (_("format names only valid inside bundles"));
5229           error_reset_cur_vinsn ();
5230           return;
5231         }
5232       if (cur_vinsn.format != XTENSA_UNDEFINED)
5233         as_warn (_("multiple formats specified for one bundle; using '%s'"),
5234                  opname);
5235       cur_vinsn.format = fmt;
5236       free (has_underbar ? opname - 1 : opname);
5237       error_reset_cur_vinsn ();
5238       return;
5239     }
5240
5241   /* Parse the arguments.  */
5242   if (parse_arguments (&orig_insn, num_args, arg_strings))
5243     {
5244       as_bad (_("syntax error"));
5245       error_reset_cur_vinsn ();
5246       return;
5247     }
5248
5249   /* Free the opcode and argument strings, now that they've been parsed.  */
5250   free (has_underbar ? opname - 1 : opname);
5251   opname = 0;
5252   while (num_args-- > 0)
5253     free (arg_strings[num_args]);
5254
5255   /* Get expressions for invisible operands.  */
5256   if (get_invisible_operands (&orig_insn))
5257     {
5258       error_reset_cur_vinsn ();
5259       return;
5260     }
5261
5262   /* Check for the right number and type of arguments.  */
5263   if (tinsn_check_arguments (&orig_insn))
5264     {
5265       error_reset_cur_vinsn ();
5266       return;
5267     }
5268
5269   dwarf2_where (&orig_insn.loc);
5270
5271   xg_add_branch_and_loop_targets (&orig_insn);
5272
5273   /* Special-case for "entry" instruction.  */
5274   if (orig_insn.opcode == xtensa_entry_opcode)
5275     {
5276       /* Check that the third opcode (#2) is >= 16.  */
5277       if (orig_insn.ntok >= 3)
5278         {
5279           expressionS *exp = &orig_insn.tok[2];
5280           switch (exp->X_op)
5281             {
5282             case O_constant:
5283               if (exp->X_add_number < 16)
5284                 as_warn (_("entry instruction with stack decrement < 16"));
5285               break;
5286
5287             default:
5288               as_warn (_("entry instruction with non-constant decrement"));
5289             }
5290         }
5291     }
5292
5293   /* Finish it off:
5294      assemble_tokens (opcode, tok, ntok);
5295      expand the tokens from the orig_insn into the
5296      stack of instructions that will not expand
5297      unless required at relaxation time.  */
5298
5299   if (!cur_vinsn.inside_bundle)
5300     emit_single_op (&orig_insn);
5301   else /* We are inside a bundle.  */
5302     {
5303       cur_vinsn.slots[cur_vinsn.num_slots] = orig_insn;
5304       cur_vinsn.num_slots++;
5305       if (*input_line_pointer == '}'
5306           || *(input_line_pointer - 1) == '}'
5307           || *(input_line_pointer - 2) == '}')
5308         finish_vinsn (&cur_vinsn);
5309     }
5310
5311   /* We've just emitted a new instruction so clear the list of labels.  */
5312   xtensa_clear_insn_labels ();
5313 }
5314
5315
5316 /* HANDLE_ALIGN hook */
5317
5318 /* For a .align directive, we mark the previous block with the alignment
5319    information.  This will be placed in the object file in the
5320    property section corresponding to this section.  */
5321
5322 void
5323 xtensa_handle_align (fragS *fragP)
5324 {
5325   if (linkrelax
5326       && ! fragP->tc_frag_data.is_literal
5327       && (fragP->fr_type == rs_align
5328           || fragP->fr_type == rs_align_code)
5329       && fragP->fr_address + fragP->fr_fix > 0
5330       && fragP->fr_offset > 0
5331       && now_seg != bss_section)
5332     {
5333       fragP->tc_frag_data.is_align = TRUE;
5334       fragP->tc_frag_data.alignment = fragP->fr_offset;
5335     }
5336
5337   if (fragP->fr_type == rs_align_test)
5338     {
5339       int count;
5340       count = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
5341       if (count != 0)
5342         as_bad_where (fragP->fr_file, fragP->fr_line,
5343                       _("unaligned entry instruction"));
5344     }
5345 }
5346
5347
5348 /* TC_FRAG_INIT hook */
5349
5350 void
5351 xtensa_frag_init (fragS *frag)
5352 {
5353   xtensa_set_frag_assembly_state (frag);
5354 }
5355
5356
5357 symbolS *
5358 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
5359 {
5360   return NULL;
5361 }
5362
5363
5364 /* Round up a section size to the appropriate boundary.  */
5365
5366 valueT
5367 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
5368 {
5369   return size;                  /* Byte alignment is fine.  */
5370 }
5371
5372
5373 long
5374 md_pcrel_from (fixS *fixP)
5375 {
5376   char *insn_p;
5377   static xtensa_insnbuf insnbuf = NULL;
5378   static xtensa_insnbuf slotbuf = NULL;
5379   int opnum;
5380   uint32 opnd_value;
5381   xtensa_opcode opcode;
5382   xtensa_format fmt;
5383   int slot;
5384   xtensa_isa isa = xtensa_default_isa;
5385   valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
5386   bfd_boolean alt_reloc;
5387
5388   if (fixP->fx_r_type == BFD_RELOC_XTENSA_ASM_EXPAND)
5389     return 0;
5390
5391   if (!insnbuf)
5392     {
5393       insnbuf = xtensa_insnbuf_alloc (isa);
5394       slotbuf = xtensa_insnbuf_alloc (isa);
5395     }
5396
5397   insn_p = &fixP->fx_frag->fr_literal[fixP->fx_where];
5398   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) insn_p, 0);
5399   fmt = xtensa_format_decode (isa, insnbuf);
5400
5401   if (fmt == XTENSA_UNDEFINED)
5402     as_fatal (_("bad instruction format"));
5403
5404   if (decode_reloc (fixP->fx_r_type, &slot, &alt_reloc) != 0)
5405     as_fatal (_("invalid relocation"));
5406
5407   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
5408   opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
5409
5410   /* Check for "alternate" relocations (operand not specified).  None
5411      of the current uses for these are really PC-relative.  */
5412   if (alt_reloc || opcode == xtensa_const16_opcode)
5413     {
5414       if (opcode != xtensa_l32r_opcode
5415           && opcode != xtensa_const16_opcode)
5416         as_fatal (_("invalid relocation for '%s' instruction"),
5417                   xtensa_opcode_name (isa, opcode));
5418       return 0;
5419     }
5420
5421   opnum = get_relaxable_immed (opcode);
5422   opnd_value = 0;
5423   if (xtensa_operand_is_PCrelative (isa, opcode, opnum) != 1
5424       || xtensa_operand_do_reloc (isa, opcode, opnum, &opnd_value, addr))
5425     {
5426       as_bad_where (fixP->fx_file,
5427                     fixP->fx_line,
5428                     _("invalid relocation for operand %d of '%s'"),
5429                     opnum, xtensa_opcode_name (isa, opcode));
5430       return 0;
5431     }
5432   return 0 - opnd_value;
5433 }
5434
5435
5436 /* TC_FORCE_RELOCATION hook */
5437
5438 int
5439 xtensa_force_relocation (fixS *fix)
5440 {
5441   switch (fix->fx_r_type)
5442     {
5443     case BFD_RELOC_XTENSA_ASM_EXPAND:
5444     case BFD_RELOC_XTENSA_SLOT0_ALT:
5445     case BFD_RELOC_XTENSA_SLOT1_ALT:
5446     case BFD_RELOC_XTENSA_SLOT2_ALT:
5447     case BFD_RELOC_XTENSA_SLOT3_ALT:
5448     case BFD_RELOC_XTENSA_SLOT4_ALT:
5449     case BFD_RELOC_XTENSA_SLOT5_ALT:
5450     case BFD_RELOC_XTENSA_SLOT6_ALT:
5451     case BFD_RELOC_XTENSA_SLOT7_ALT:
5452     case BFD_RELOC_XTENSA_SLOT8_ALT:
5453     case BFD_RELOC_XTENSA_SLOT9_ALT:
5454     case BFD_RELOC_XTENSA_SLOT10_ALT:
5455     case BFD_RELOC_XTENSA_SLOT11_ALT:
5456     case BFD_RELOC_XTENSA_SLOT12_ALT:
5457     case BFD_RELOC_XTENSA_SLOT13_ALT:
5458     case BFD_RELOC_XTENSA_SLOT14_ALT:
5459       return 1;
5460     default:
5461       break;
5462     }
5463
5464   if (linkrelax && fix->fx_addsy
5465       && relaxable_section (S_GET_SEGMENT (fix->fx_addsy)))
5466     return 1;
5467
5468   return generic_force_reloc (fix);
5469 }
5470
5471
5472 /* TC_VALIDATE_FIX_SUB hook */
5473
5474 int
5475 xtensa_validate_fix_sub (fixS *fix)
5476 {
5477   segT add_symbol_segment, sub_symbol_segment;
5478
5479   /* The difference of two symbols should be resolved by the assembler when
5480      linkrelax is not set.  If the linker may relax the section containing
5481      the symbols, then an Xtensa DIFF relocation must be generated so that
5482      the linker knows to adjust the difference value.  */
5483   if (!linkrelax || fix->fx_addsy == NULL)
5484     return 0;
5485
5486   /* Make sure both symbols are in the same segment, and that segment is
5487      "normal" and relaxable.  If the segment is not "normal", then the
5488      fix is not valid.  If the segment is not "relaxable", then the fix
5489      should have been handled earlier.  */
5490   add_symbol_segment = S_GET_SEGMENT (fix->fx_addsy);
5491   if (! SEG_NORMAL (add_symbol_segment) ||
5492       ! relaxable_section (add_symbol_segment))
5493     return 0;
5494   sub_symbol_segment = S_GET_SEGMENT (fix->fx_subsy);
5495   return (sub_symbol_segment == add_symbol_segment);
5496 }
5497
5498
5499 /* NO_PSEUDO_DOT hook */
5500
5501 /* This function has nothing to do with pseudo dots, but this is the
5502    nearest macro to where the check needs to take place.  FIXME: This
5503    seems wrong.  */
5504
5505 bfd_boolean
5506 xtensa_check_inside_bundle (void)
5507 {
5508   if (cur_vinsn.inside_bundle && input_line_pointer[-1] == '.')
5509     as_bad (_("directives are not valid inside bundles"));
5510
5511   /* This function must always return FALSE because it is called via a
5512      macro that has nothing to do with bundling.  */
5513   return FALSE;
5514 }
5515
5516
5517 /* md_elf_section_change_hook */
5518
5519 void
5520 xtensa_elf_section_change_hook (void)
5521 {
5522   /* Set up the assembly state.  */
5523   if (!frag_now->tc_frag_data.is_assembly_state_set)
5524     xtensa_set_frag_assembly_state (frag_now);
5525 }
5526
5527
5528 /* tc_fix_adjustable hook */
5529
5530 bfd_boolean
5531 xtensa_fix_adjustable (fixS *fixP)
5532 {
5533   /* An offset is not allowed in combination with the difference of two
5534      symbols, but that cannot be easily detected after a local symbol
5535      has been adjusted to a (section+offset) form.  Return 0 so that such
5536      an fix will not be adjusted.  */
5537   if (fixP->fx_subsy && fixP->fx_addsy && fixP->fx_offset
5538       && relaxable_section (S_GET_SEGMENT (fixP->fx_subsy)))
5539     return 0;
5540
5541   /* We need the symbol name for the VTABLE entries.  */
5542   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5543       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5544     return 0;
5545
5546   return 1;
5547 }
5548
5549
5550 void
5551 md_apply_fix (fixS *fixP, valueT *valP, segT seg)
5552 {
5553   char *const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
5554   valueT val;
5555
5556   switch (fixP->fx_r_type)
5557     {
5558     case BFD_RELOC_32:
5559     case BFD_RELOC_16:
5560     case BFD_RELOC_8:
5561       if (linkrelax && fixP->fx_subsy)
5562         {
5563           switch (fixP->fx_r_type)
5564             {
5565             case BFD_RELOC_8:
5566               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF8;
5567               break;
5568             case BFD_RELOC_16:
5569               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF16;
5570               break;
5571             case BFD_RELOC_32:
5572               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF32;
5573               break;
5574             default:
5575               break;
5576             }
5577
5578           /* An offset is only allowed when it results from adjusting a
5579              local symbol into a section-relative offset.  If the offset
5580              came from the original expression, tc_fix_adjustable will have
5581              prevented the fix from being converted to a section-relative
5582              form so that we can flag the error here.  */
5583           if (fixP->fx_offset != 0 && !symbol_section_p (fixP->fx_addsy))
5584             as_bad_where (fixP->fx_file, fixP->fx_line,
5585                           _("cannot represent subtraction with an offset"));
5586
5587           val = (S_GET_VALUE (fixP->fx_addsy) + fixP->fx_offset
5588                  - S_GET_VALUE (fixP->fx_subsy));
5589
5590           /* The difference value gets written out, and the DIFF reloc
5591              identifies the address of the subtracted symbol (i.e., the one
5592              with the lowest address).  */
5593           *valP = val;
5594           fixP->fx_offset -= val;
5595           fixP->fx_subsy = NULL;
5596         }
5597       else if (! fixP->fx_addsy)
5598         {
5599           val = *valP;
5600           fixP->fx_done = 1;
5601         }
5602       else
5603         break;
5604       md_number_to_chars (fixpos, val, fixP->fx_size);
5605       fixP->fx_no_overflow = 0; /* Use the standard overflow check.  */
5606       break;
5607
5608     case BFD_RELOC_XTENSA_SLOT0_OP:
5609     case BFD_RELOC_XTENSA_SLOT1_OP:
5610     case BFD_RELOC_XTENSA_SLOT2_OP:
5611     case BFD_RELOC_XTENSA_SLOT3_OP:
5612     case BFD_RELOC_XTENSA_SLOT4_OP:
5613     case BFD_RELOC_XTENSA_SLOT5_OP:
5614     case BFD_RELOC_XTENSA_SLOT6_OP:
5615     case BFD_RELOC_XTENSA_SLOT7_OP:
5616     case BFD_RELOC_XTENSA_SLOT8_OP:
5617     case BFD_RELOC_XTENSA_SLOT9_OP:
5618     case BFD_RELOC_XTENSA_SLOT10_OP:
5619     case BFD_RELOC_XTENSA_SLOT11_OP:
5620     case BFD_RELOC_XTENSA_SLOT12_OP:
5621     case BFD_RELOC_XTENSA_SLOT13_OP:
5622     case BFD_RELOC_XTENSA_SLOT14_OP:
5623       if (linkrelax)
5624         {
5625           /* Write the tentative value of a PC-relative relocation to a
5626              local symbol into the instruction.  The value will be ignored
5627              by the linker, and it makes the object file disassembly
5628              readable when all branch targets are encoded in relocations.  */
5629
5630           assert (fixP->fx_addsy);
5631           if (S_GET_SEGMENT (fixP->fx_addsy) == seg && !fixP->fx_plt
5632               && !S_FORCE_RELOC (fixP->fx_addsy, 1))
5633             {
5634               val = (S_GET_VALUE (fixP->fx_addsy) + fixP->fx_offset
5635                      - md_pcrel_from (fixP));
5636               (void) xg_apply_fix_value (fixP, val);
5637             }
5638         }
5639       else if (! fixP->fx_addsy)
5640         {
5641           val = *valP;
5642           if (xg_apply_fix_value (fixP, val))
5643             fixP->fx_done = 1;
5644         }
5645       break;
5646
5647     case BFD_RELOC_XTENSA_PLT:
5648     case BFD_RELOC_XTENSA_ASM_EXPAND:
5649     case BFD_RELOC_XTENSA_SLOT0_ALT:
5650     case BFD_RELOC_XTENSA_SLOT1_ALT:
5651     case BFD_RELOC_XTENSA_SLOT2_ALT:
5652     case BFD_RELOC_XTENSA_SLOT3_ALT:
5653     case BFD_RELOC_XTENSA_SLOT4_ALT:
5654     case BFD_RELOC_XTENSA_SLOT5_ALT:
5655     case BFD_RELOC_XTENSA_SLOT6_ALT:
5656     case BFD_RELOC_XTENSA_SLOT7_ALT:
5657     case BFD_RELOC_XTENSA_SLOT8_ALT:
5658     case BFD_RELOC_XTENSA_SLOT9_ALT:
5659     case BFD_RELOC_XTENSA_SLOT10_ALT:
5660     case BFD_RELOC_XTENSA_SLOT11_ALT:
5661     case BFD_RELOC_XTENSA_SLOT12_ALT:
5662     case BFD_RELOC_XTENSA_SLOT13_ALT:
5663     case BFD_RELOC_XTENSA_SLOT14_ALT:
5664       /* These all need to be resolved at link-time.  Do nothing now.  */
5665       break;
5666
5667     case BFD_RELOC_VTABLE_INHERIT:
5668     case BFD_RELOC_VTABLE_ENTRY:
5669       fixP->fx_done = 0;
5670       break;
5671
5672     default:
5673       as_bad (_("unhandled local relocation fix %s"),
5674               bfd_get_reloc_code_name (fixP->fx_r_type));
5675     }
5676 }
5677
5678
5679 char *
5680 md_atof (int type, char *litP, int *sizeP)
5681 {
5682   int prec;
5683   LITTLENUM_TYPE words[4];
5684   char *t;
5685   int i;
5686
5687   switch (type)
5688     {
5689     case 'f':
5690       prec = 2;
5691       break;
5692
5693     case 'd':
5694       prec = 4;
5695       break;
5696
5697     default:
5698       *sizeP = 0;
5699       return "bad call to md_atof";
5700     }
5701
5702   t = atof_ieee (input_line_pointer, type, words);
5703   if (t)
5704     input_line_pointer = t;
5705
5706   *sizeP = prec * 2;
5707
5708   for (i = prec - 1; i >= 0; i--)
5709     {
5710       int idx = i;
5711       if (target_big_endian)
5712         idx = (prec - 1 - i);
5713
5714       md_number_to_chars (litP, (valueT) words[idx], 2);
5715       litP += 2;
5716     }
5717
5718   return NULL;
5719 }
5720
5721
5722 int
5723 md_estimate_size_before_relax (fragS *fragP, segT seg ATTRIBUTE_UNUSED)
5724 {
5725   return total_frag_text_expansion (fragP);
5726 }
5727
5728
5729 /* Translate internal representation of relocation info to BFD target
5730    format.  */
5731
5732 arelent *
5733 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
5734 {
5735   arelent *reloc;
5736
5737   reloc = (arelent *) xmalloc (sizeof (arelent));
5738   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5739   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5740   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5741
5742   /* Make sure none of our internal relocations make it this far.
5743      They'd better have been fully resolved by this point.  */
5744   assert ((int) fixp->fx_r_type > 0);
5745
5746   reloc->addend = fixp->fx_offset;
5747
5748   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
5749   if (reloc->howto == NULL)
5750     {
5751       as_bad_where (fixp->fx_file, fixp->fx_line,
5752                     _("cannot represent `%s' relocation in object file"),
5753                     bfd_get_reloc_code_name (fixp->fx_r_type));
5754       free (reloc->sym_ptr_ptr);
5755       free (reloc);
5756       return NULL;
5757     }
5758
5759   if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
5760     as_fatal (_("internal error? cannot generate `%s' relocation"),
5761               bfd_get_reloc_code_name (fixp->fx_r_type));
5762
5763   return reloc;
5764 }
5765
5766 \f
5767 /* Checks for resource conflicts between instructions.  */
5768
5769 /* The func unit stuff could be implemented as bit-vectors rather
5770    than the iterative approach here.  If it ends up being too
5771    slow, we will switch it.  */
5772
5773 resource_table *
5774 new_resource_table (void *data,
5775                     int cycles,
5776                     int nu,
5777                     unit_num_copies_func uncf,
5778                     opcode_num_units_func onuf,
5779                     opcode_funcUnit_use_unit_func ouuf,
5780                     opcode_funcUnit_use_stage_func ousf)
5781 {
5782   int i;
5783   resource_table *rt = (resource_table *) xmalloc (sizeof (resource_table));
5784   rt->data = data;
5785   rt->cycles = cycles;
5786   rt->allocated_cycles = cycles;
5787   rt->num_units = nu;
5788   rt->unit_num_copies = uncf;
5789   rt->opcode_num_units = onuf;
5790   rt->opcode_unit_use = ouuf;
5791   rt->opcode_unit_stage = ousf;
5792
5793   rt->units = (unsigned char **) xcalloc (cycles, sizeof (unsigned char *));
5794   for (i = 0; i < cycles; i++)
5795     rt->units[i] = (unsigned char *) xcalloc (nu, sizeof (unsigned char));
5796
5797   return rt;
5798 }
5799
5800
5801 void
5802 clear_resource_table (resource_table *rt)
5803 {
5804   int i, j;
5805   for (i = 0; i < rt->allocated_cycles; i++)
5806     for (j = 0; j < rt->num_units; j++)
5807       rt->units[i][j] = 0;
5808 }
5809
5810
5811 /* We never shrink it, just fake it into thinking so.  */
5812
5813 void
5814 resize_resource_table (resource_table *rt, int cycles)
5815 {
5816   int i, old_cycles;
5817
5818   rt->cycles = cycles;
5819   if (cycles <= rt->allocated_cycles)
5820     return;
5821
5822   old_cycles = rt->allocated_cycles;
5823   rt->allocated_cycles = cycles;
5824
5825   rt->units = xrealloc (rt->units,
5826                         rt->allocated_cycles * sizeof (unsigned char *));
5827   for (i = 0; i < old_cycles; i++)
5828     rt->units[i] = xrealloc (rt->units[i],
5829                              rt->num_units * sizeof (unsigned char));
5830   for (i = old_cycles; i < cycles; i++)
5831     rt->units[i] = xcalloc (rt->num_units, sizeof (unsigned char));
5832 }
5833
5834
5835 bfd_boolean
5836 resources_available (resource_table *rt, xtensa_opcode opcode, int cycle)
5837 {
5838   int i;
5839   int uses = (rt->opcode_num_units) (rt->data, opcode);
5840
5841   for (i = 0; i < uses; i++)
5842     {
5843       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5844       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5845       int copies_in_use = rt->units[stage + cycle][unit];
5846       int copies = (rt->unit_num_copies) (rt->data, unit);
5847       if (copies_in_use >= copies)
5848         return FALSE;
5849     }
5850   return TRUE;
5851 }
5852
5853
5854 void
5855 reserve_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
5856 {
5857   int i;
5858   int uses = (rt->opcode_num_units) (rt->data, opcode);
5859
5860   for (i = 0; i < uses; i++)
5861     {
5862       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5863       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5864       /* Note that this allows resources to be oversubscribed.  That's
5865          essential to the way the optional scheduler works.
5866          resources_available reports when a resource is over-subscribed,
5867          so it's easy to tell.  */
5868       rt->units[stage + cycle][unit]++;
5869     }
5870 }
5871
5872
5873 void
5874 release_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
5875 {
5876   int i;
5877   int uses = (rt->opcode_num_units) (rt->data, opcode);
5878
5879   for (i = 0; i < uses; i++)
5880     {
5881       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5882       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5883       assert (rt->units[stage + cycle][unit] > 0);
5884       rt->units[stage + cycle][unit]--;
5885     }
5886 }
5887
5888
5889 /* Wrapper functions make parameterized resource reservation
5890    more convenient.  */
5891
5892 int
5893 opcode_funcUnit_use_unit (void *data, xtensa_opcode opcode, int idx)
5894 {
5895   xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
5896   return use->unit;
5897 }
5898
5899
5900 int
5901 opcode_funcUnit_use_stage (void *data, xtensa_opcode opcode, int idx)
5902 {
5903   xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
5904   return use->stage;
5905 }
5906
5907
5908 /* Note that this function does not check issue constraints, but
5909    solely whether the hardware is available to execute the given
5910    instructions together.  It also doesn't check if the tinsns
5911    write the same state, or access the same tieports.  That is
5912    checked by check_t1_t2_reads_and_writes.  */
5913
5914 static bfd_boolean
5915 resources_conflict (vliw_insn *vinsn)
5916 {
5917   int i;
5918   static resource_table *rt = NULL;
5919
5920   /* This is the most common case by far.  Optimize it.  */
5921   if (vinsn->num_slots == 1)
5922     return FALSE;
5923
5924   if (rt == NULL)
5925     {
5926       xtensa_isa isa = xtensa_default_isa;
5927       rt = new_resource_table
5928         (isa, xtensa_isa_num_pipe_stages (isa),
5929          xtensa_isa_num_funcUnits (isa),
5930          (unit_num_copies_func) xtensa_funcUnit_num_copies,
5931          (opcode_num_units_func) xtensa_opcode_num_funcUnit_uses,
5932          opcode_funcUnit_use_unit,
5933          opcode_funcUnit_use_stage);
5934     }
5935
5936   clear_resource_table (rt);
5937
5938   for (i = 0; i < vinsn->num_slots; i++)
5939     {
5940       if (!resources_available (rt, vinsn->slots[i].opcode, 0))
5941         return TRUE;
5942       reserve_resources (rt, vinsn->slots[i].opcode, 0);
5943     }
5944
5945   return FALSE;
5946 }
5947
5948 \f
5949 /* finish_vinsn, emit_single_op and helper functions.  */
5950
5951 static bfd_boolean find_vinsn_conflicts (vliw_insn *);
5952 static xtensa_format xg_find_narrowest_format (vliw_insn *);
5953 static void bundle_single_op (TInsn *);
5954 static void xg_assemble_vliw_tokens (vliw_insn *);
5955
5956
5957 /* We have reached the end of a bundle; emit into the frag.  */
5958
5959 static void
5960 finish_vinsn (vliw_insn *vinsn)
5961 {
5962   IStack slotstack;
5963   int i;
5964   char *file_name;
5965   unsigned line;
5966
5967   if (find_vinsn_conflicts (vinsn))
5968     {
5969       xg_clear_vinsn (vinsn);
5970       return;
5971     }
5972
5973   /* First, find a format that works.  */
5974   if (vinsn->format == XTENSA_UNDEFINED)
5975     vinsn->format = xg_find_narrowest_format (vinsn);
5976
5977   if (vinsn->format == XTENSA_UNDEFINED)
5978     {
5979       as_where (&file_name, &line);
5980       as_bad_where (file_name, line,
5981                     _("couldn't find a valid instruction format"));
5982       fprintf (stderr, _("    ops were: "));
5983       for (i = 0; i < vinsn->num_slots; i++)
5984         fprintf (stderr, _(" %s;"),
5985                  xtensa_opcode_name (xtensa_default_isa,
5986                                      vinsn->slots[i].opcode));
5987       fprintf (stderr, _("\n"));
5988       xg_clear_vinsn (vinsn);
5989       return;
5990     }
5991
5992   if (vinsn->num_slots
5993       != xtensa_format_num_slots (xtensa_default_isa, vinsn->format))
5994     {
5995       as_bad (_("format '%s' allows %d slots, but there are %d opcodes"),
5996               xtensa_format_name (xtensa_default_isa, vinsn->format),
5997               xtensa_format_num_slots (xtensa_default_isa, vinsn->format),
5998               vinsn->num_slots);
5999       xg_clear_vinsn (vinsn);
6000       return;
6001     }
6002
6003   if (resources_conflict (vinsn))
6004     {
6005       as_where (&file_name, &line);
6006       as_bad_where (file_name, line, _("illegal resource usage in bundle"));
6007       fprintf (stderr, "    ops were: ");
6008       for (i = 0; i < vinsn->num_slots; i++)
6009         fprintf (stderr, " %s;",
6010                  xtensa_opcode_name (xtensa_default_isa,
6011                                      vinsn->slots[i].opcode));
6012       fprintf (stderr, "\n");
6013       xg_clear_vinsn (vinsn);
6014       return;
6015     }
6016
6017   for (i = 0; i < vinsn->num_slots; i++)
6018     {
6019       if (vinsn->slots[i].opcode != XTENSA_UNDEFINED)
6020         {
6021           symbolS *lit_sym = NULL;
6022           int j;
6023           bfd_boolean e = FALSE;
6024           bfd_boolean saved_density = density_supported;
6025
6026           /* We don't want to narrow ops inside multi-slot bundles.  */
6027           if (vinsn->num_slots > 1)
6028             density_supported = FALSE;
6029
6030           istack_init (&slotstack);
6031           if (vinsn->slots[i].opcode == xtensa_nop_opcode)
6032             {
6033               vinsn->slots[i].opcode =
6034                 xtensa_format_slot_nop_opcode (xtensa_default_isa,
6035                                                vinsn->format, i);
6036               vinsn->slots[i].ntok = 0;
6037             }
6038
6039           if (xg_expand_assembly_insn (&slotstack, &vinsn->slots[i]))
6040             {
6041               e = TRUE;
6042               continue;
6043             }
6044
6045           density_supported = saved_density;
6046
6047           if (e)
6048             {
6049               xg_clear_vinsn (vinsn);
6050               return;
6051             }
6052
6053           for (j = 0; j < slotstack.ninsn; j++)
6054             {
6055               TInsn *insn = &slotstack.insn[j];
6056               if (insn->insn_type == ITYPE_LITERAL)
6057                 {
6058                   assert (lit_sym == NULL);
6059                   lit_sym = xg_assemble_literal (insn);
6060                 }
6061               else
6062                 {
6063                   assert (insn->insn_type == ITYPE_INSN);
6064                   if (lit_sym)
6065                     xg_resolve_literals (insn, lit_sym);
6066                   if (j != slotstack.ninsn - 1)
6067                     emit_single_op (insn);
6068                 }
6069             }
6070
6071           if (vinsn->num_slots > 1)
6072             {
6073               if (opcode_fits_format_slot
6074                   (slotstack.insn[slotstack.ninsn - 1].opcode,
6075                    vinsn->format, i))
6076                 {
6077                   vinsn->slots[i] = slotstack.insn[slotstack.ninsn - 1];
6078                 }
6079               else
6080                 {
6081                   bundle_single_op (&slotstack.insn[slotstack.ninsn - 1]);
6082                   if (vinsn->format == XTENSA_UNDEFINED)
6083                     vinsn->slots[i].opcode = xtensa_nop_opcode;
6084                   else
6085                     vinsn->slots[i].opcode
6086                       = xtensa_format_slot_nop_opcode (xtensa_default_isa,
6087                                                        vinsn->format, i);
6088
6089                   vinsn->slots[i].ntok = 0;
6090                 }
6091             }
6092           else
6093             {
6094               vinsn->slots[0] = slotstack.insn[slotstack.ninsn - 1];
6095               vinsn->format = XTENSA_UNDEFINED;
6096             }
6097         }
6098     }
6099
6100   /* Now check resource conflicts on the modified bundle.  */
6101   if (resources_conflict (vinsn))
6102     {
6103       as_where (&file_name, &line);
6104       as_bad_where (file_name, line, _("illegal resource usage in bundle"));
6105       fprintf (stderr, "    ops were: ");
6106       for (i = 0; i < vinsn->num_slots; i++)
6107         fprintf (stderr, " %s;",
6108                  xtensa_opcode_name (xtensa_default_isa,
6109                                      vinsn->slots[i].opcode));
6110       fprintf (stderr, "\n");
6111       xg_clear_vinsn (vinsn);
6112       return;
6113     }
6114
6115   /* First, find a format that works.  */
6116   if (vinsn->format == XTENSA_UNDEFINED)
6117       vinsn->format = xg_find_narrowest_format (vinsn);
6118
6119   xg_assemble_vliw_tokens (vinsn);
6120
6121   xg_clear_vinsn (vinsn);
6122 }
6123
6124
6125 /* Given an vliw instruction, what conflicts are there in register
6126    usage and in writes to states and queues?
6127
6128    This function does two things:
6129    1. Reports an error when a vinsn contains illegal combinations
6130       of writes to registers states or queues.
6131    2. Marks individual tinsns as not relaxable if the combination
6132       contains antidependencies.
6133
6134    Job 2 handles things like swap semantics in instructions that need
6135    to be relaxed.  For example,
6136
6137         addi a0, a1, 100000
6138
6139    normally would be relaxed to
6140
6141         l32r a0, some_label
6142         add a0, a1, a0
6143
6144    _but_, if the above instruction is bundled with an a0 reader, e.g.,
6145
6146         { addi a0, a1, 10000 ; add a2, a0, a4 ; }
6147
6148    then we can't relax it into
6149
6150         l32r a0, some_label
6151         { add a0, a1, a0 ; add a2, a0, a4 ; }
6152
6153    because the value of a0 is trashed before the second add can read it.  */
6154
6155 static char check_t1_t2_reads_and_writes (TInsn *, TInsn *);
6156
6157 static bfd_boolean
6158 find_vinsn_conflicts (vliw_insn *vinsn)
6159 {
6160   int i, j;
6161   int branches = 0;
6162   xtensa_isa isa = xtensa_default_isa;
6163
6164   assert (!past_xtensa_end);
6165
6166   for (i = 0 ; i < vinsn->num_slots; i++)
6167     {
6168       TInsn *op1 = &vinsn->slots[i];
6169       if (op1->is_specific_opcode)
6170         op1->keep_wide = TRUE;
6171       else
6172         op1->keep_wide = FALSE;
6173     }
6174
6175   for (i = 0 ; i < vinsn->num_slots; i++)
6176     {
6177       TInsn *op1 = &vinsn->slots[i];
6178
6179       if (xtensa_opcode_is_branch (isa, op1->opcode) == 1)
6180         branches++;
6181
6182       for (j = 0; j < vinsn->num_slots; j++)
6183         {
6184           if (i != j)
6185             {
6186               TInsn *op2 = &vinsn->slots[j];
6187               char conflict_type = check_t1_t2_reads_and_writes (op1, op2);
6188               switch (conflict_type)
6189                 {
6190                 case 'c':
6191                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same register"),
6192                           xtensa_opcode_name (isa, op1->opcode), i,
6193                           xtensa_opcode_name (isa, op2->opcode), j);
6194                   return TRUE;
6195                 case 'd':
6196                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same state"),
6197                           xtensa_opcode_name (isa, op1->opcode), i,
6198                           xtensa_opcode_name (isa, op2->opcode), j);
6199                   return TRUE;
6200                 case 'e':
6201                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same queue"),
6202                           xtensa_opcode_name (isa, op1->opcode), i,
6203                           xtensa_opcode_name (isa, op2->opcode), j);
6204                   return TRUE;
6205                 case 'f':
6206                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) both have volatile queue accesses"),
6207                           xtensa_opcode_name (isa, op1->opcode), i,
6208                           xtensa_opcode_name (isa, op2->opcode), j);
6209                   return TRUE;
6210                 default:
6211                   /* Everything is OK.  */
6212                   break;
6213                 }
6214               op2->is_specific_opcode = (op2->is_specific_opcode
6215                                          || conflict_type == 'a');
6216             }
6217         }
6218     }
6219
6220   if (branches > 1)
6221     {
6222       as_bad (_("multiple branches or jumps in the same bundle"));
6223       return TRUE;
6224     }
6225
6226   return FALSE;
6227 }
6228
6229
6230 /* Check how the state used by t1 and t2 relate.
6231    Cases found are:
6232
6233    case A: t1 reads a register t2 writes (an antidependency within a bundle)
6234    case B: no relationship between what is read and written (both could
6235            read the same reg though)
6236    case C: t1 writes a register t2 writes (a register conflict within a
6237            bundle)
6238    case D: t1 writes a state that t2 also writes
6239    case E: t1 writes a tie queue that t2 also writes
6240    case F: two volatile queue accesses
6241 */
6242
6243 static char
6244 check_t1_t2_reads_and_writes (TInsn *t1, TInsn *t2)
6245 {
6246   xtensa_isa isa = xtensa_default_isa;
6247   xtensa_regfile t1_regfile, t2_regfile;
6248   int t1_reg, t2_reg;
6249   int t1_base_reg, t1_last_reg;
6250   int t2_base_reg, t2_last_reg;
6251   char t1_inout, t2_inout;
6252   int i, j;
6253   char conflict = 'b';
6254   int t1_states;
6255   int t2_states;
6256   int t1_interfaces;
6257   int t2_interfaces;
6258   bfd_boolean t1_volatile = FALSE;
6259   bfd_boolean t2_volatile = FALSE;
6260
6261   /* Check registers.  */
6262   for (j = 0; j < t2->ntok; j++)
6263     {
6264       if (xtensa_operand_is_register (isa, t2->opcode, j) != 1)
6265         continue;
6266
6267       t2_regfile = xtensa_operand_regfile (isa, t2->opcode, j);
6268       t2_base_reg = t2->tok[j].X_add_number;
6269       t2_last_reg = t2_base_reg + xtensa_operand_num_regs (isa, t2->opcode, j);
6270
6271       for (i = 0; i < t1->ntok; i++)
6272         {
6273           if (xtensa_operand_is_register (isa, t1->opcode, i) != 1)
6274             continue;
6275
6276           t1_regfile = xtensa_operand_regfile (isa, t1->opcode, i);
6277
6278           if (t1_regfile != t2_regfile)
6279             continue;
6280
6281           t1_inout = xtensa_operand_inout (isa, t1->opcode, i);
6282           t2_inout = xtensa_operand_inout (isa, t2->opcode, j);
6283
6284           if (xtensa_operand_is_known_reg (isa, t1->opcode, i) == 0
6285               || xtensa_operand_is_known_reg (isa, t2->opcode, j) == 0)
6286             {
6287               if (t1_inout == 'm' || t1_inout == 'o'
6288                   || t2_inout == 'm' || t2_inout == 'o')
6289                 {
6290                   conflict = 'a';
6291                   continue;
6292                 }
6293             }
6294
6295           t1_base_reg = t1->tok[i].X_add_number;
6296           t1_last_reg = (t1_base_reg
6297                          + xtensa_operand_num_regs (isa, t1->opcode, i));
6298
6299           for (t1_reg = t1_base_reg; t1_reg < t1_last_reg; t1_reg++)
6300             {
6301               for (t2_reg = t2_base_reg; t2_reg < t2_last_reg; t2_reg++)
6302                 {
6303                   if (t1_reg != t2_reg)
6304                     continue;
6305
6306                   if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o'))
6307                     {
6308                       conflict = 'a';
6309                       continue;
6310                     }
6311
6312                   if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o'))
6313                     {
6314                       conflict = 'a';
6315                       continue;
6316                     }
6317
6318                   if (t1_inout != 'i' && t2_inout != 'i')
6319                     return 'c';
6320                 }
6321             }
6322         }
6323     }
6324
6325   /* Check states.  */
6326   t1_states = xtensa_opcode_num_stateOperands (isa, t1->opcode);
6327   t2_states = xtensa_opcode_num_stateOperands (isa, t2->opcode);
6328   for (j = 0; j < t2_states; j++)
6329     {
6330       xtensa_state t2_so = xtensa_stateOperand_state (isa, t2->opcode, j);
6331       t2_inout = xtensa_stateOperand_inout (isa, t2->opcode, j);
6332       for (i = 0; i < t1_states; i++)
6333         {
6334           xtensa_state t1_so = xtensa_stateOperand_state (isa, t1->opcode, i);
6335           t1_inout = xtensa_stateOperand_inout (isa, t1->opcode, i);
6336           if (t1_so != t2_so)
6337             continue;
6338
6339           if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o'))
6340             {
6341               conflict = 'a';
6342               continue;
6343             }
6344
6345           if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o'))
6346             {
6347               conflict = 'a';
6348               continue;
6349             }
6350
6351           if (t1_inout != 'i' && t2_inout != 'i')
6352             return 'd';
6353         }
6354     }
6355
6356   /* Check tieports.  */
6357   t1_interfaces = xtensa_opcode_num_interfaceOperands (isa, t1->opcode);
6358   t2_interfaces = xtensa_opcode_num_interfaceOperands (isa, t2->opcode);
6359   for (j = 0; j < t2_interfaces; j++)
6360     {
6361       xtensa_interface t2_int
6362         = xtensa_interfaceOperand_interface (isa, t2->opcode, j);
6363       int t2_class = xtensa_interface_class_id (isa, t2_int);
6364
6365       t2_inout = xtensa_interface_inout (isa, j);
6366       if (xtensa_interface_has_side_effect (isa, t2_int) == 1)
6367         t2_volatile = TRUE;
6368
6369       for (i = 0; i < t1_interfaces; i++)
6370         {
6371           xtensa_interface t1_int
6372             = xtensa_interfaceOperand_interface (isa, t1->opcode, j);
6373           int t1_class = xtensa_interface_class_id (isa, t1_int);
6374
6375           t1_inout = xtensa_interface_inout (isa, i);
6376           if (xtensa_interface_has_side_effect (isa, t1_int) == 1)
6377             t1_volatile = TRUE;
6378
6379           if (t1_volatile && t2_volatile && (t1_class == t2_class))
6380             return 'f';
6381
6382           if (t1_int != t2_int)
6383             continue;
6384
6385           if (t2_inout == 'i' && t1_inout == 'o')
6386             {
6387               conflict = 'a';
6388               continue;
6389             }
6390
6391           if (t1_inout == 'i' && t2_inout == 'o')
6392             {
6393               conflict = 'a';
6394               continue;
6395             }
6396
6397           if (t1_inout != 'i' && t2_inout != 'i')
6398             return 'e';
6399         }
6400     }
6401
6402   return conflict;
6403 }
6404
6405
6406 static xtensa_format
6407 xg_find_narrowest_format (vliw_insn *vinsn)
6408 {
6409   /* Right now we assume that the ops within the vinsn are properly
6410      ordered for the slots that the programmer wanted them in.  In
6411      other words, we don't rearrange the ops in hopes of finding a
6412      better format.  The scheduler handles that.  */
6413
6414   xtensa_isa isa = xtensa_default_isa;
6415   xtensa_format format;
6416   vliw_insn v_copy = *vinsn;
6417   xtensa_opcode nop_opcode = xtensa_nop_opcode;
6418
6419   for (format = 0; format < xtensa_isa_num_formats (isa); format++)
6420     {
6421       v_copy = *vinsn;
6422       if (xtensa_format_num_slots (isa, format) == v_copy.num_slots)
6423         {
6424           int slot;
6425           int fit = 0;
6426           for (slot = 0; slot < v_copy.num_slots; slot++)
6427             {
6428               if (v_copy.slots[slot].opcode == nop_opcode)
6429                 {
6430                   v_copy.slots[slot].opcode =
6431                     xtensa_format_slot_nop_opcode (isa, format, slot);
6432                   v_copy.slots[slot].ntok = 0;
6433                 }
6434
6435               if (opcode_fits_format_slot (v_copy.slots[slot].opcode,
6436                                            format, slot))
6437                 fit++;
6438               else if (v_copy.num_slots > 1)
6439                 {
6440                   TInsn widened;
6441                   /* Try the widened version.  */
6442                   if (!v_copy.slots[slot].keep_wide
6443                       && !v_copy.slots[slot].is_specific_opcode
6444                       && xg_is_single_relaxable_insn (&v_copy.slots[slot],
6445                                                       &widened, TRUE)
6446                       && opcode_fits_format_slot (widened.opcode,
6447                                                   format, slot))
6448                     {
6449                       v_copy.slots[slot] = widened;
6450                       fit++;
6451                     }
6452                 }
6453             }
6454           if (fit == v_copy.num_slots)
6455             {
6456               *vinsn = v_copy;
6457               xtensa_format_encode (isa, format, vinsn->insnbuf);
6458               vinsn->format = format;
6459               break;
6460             }
6461         }
6462     }
6463
6464   if (format == xtensa_isa_num_formats (isa))
6465     return XTENSA_UNDEFINED;
6466
6467   return format;
6468 }
6469
6470
6471 /* Return the additional space needed in a frag
6472    for possible relaxations of any ops in a VLIW insn.
6473    Also fill out the relaxations that might be required of
6474    each tinsn in the vinsn.  */
6475
6476 static int
6477 relaxation_requirements (vliw_insn *vinsn)
6478 {
6479   int extra_space = 0;
6480   int slot;
6481
6482   for (slot = 0; slot < vinsn->num_slots; slot++)
6483     {
6484       TInsn *tinsn = &vinsn->slots[slot];
6485       if (!tinsn_has_symbolic_operands (tinsn))
6486         {
6487           /* A narrow instruction could be widened later to help
6488              alignment issues.  */
6489           if (xg_is_single_relaxable_insn (tinsn, 0, TRUE)
6490               && !tinsn->is_specific_opcode
6491               && vinsn->num_slots == 1)
6492             {
6493               /* Difference in bytes between narrow and wide insns...  */
6494               extra_space += 1;
6495               tinsn->subtype = RELAX_NARROW;
6496               tinsn->record_fix = TRUE;
6497               break;
6498             }
6499           else
6500             {
6501               tinsn->record_fix = FALSE;
6502               /* No extra_space needed.  */
6503             }
6504         }
6505       else
6506         {
6507           if (workaround_b_j_loop_end
6508               && tinsn->opcode == xtensa_jx_opcode
6509               && use_transform ())
6510             {
6511               /* Add 2 of these.  */
6512               extra_space += 3; /* for the nop size */
6513               tinsn->subtype = RELAX_ADD_NOP_IF_PRE_LOOP_END;
6514             }
6515
6516           /* Need to assemble it with space for the relocation.  */
6517           if (xg_is_relaxable_insn (tinsn, 0)
6518               && !tinsn->is_specific_opcode)
6519             {
6520               int max_size = xg_get_max_insn_widen_size (tinsn->opcode);
6521               int max_literal_size =
6522                 xg_get_max_insn_widen_literal_size (tinsn->opcode);
6523
6524               tinsn->literal_space = max_literal_size;
6525
6526               tinsn->subtype = RELAX_IMMED;
6527               tinsn->record_fix = FALSE;
6528               extra_space += max_size;
6529             }
6530           else
6531             {
6532               tinsn->record_fix = TRUE;
6533               /* No extra space needed.  */
6534             }
6535         }
6536     }
6537   return extra_space;
6538 }
6539
6540
6541 static void
6542 bundle_single_op (TInsn *orig_insn)
6543 {
6544   xtensa_isa isa = xtensa_default_isa;
6545   vliw_insn v;
6546   int slot;
6547
6548   xg_init_vinsn (&v);
6549   v.format = op_placement_table[orig_insn->opcode].narrowest;
6550   assert (v.format != XTENSA_UNDEFINED);
6551   v.num_slots = xtensa_format_num_slots (isa, v.format);
6552
6553   for (slot = 0;
6554        !opcode_fits_format_slot (orig_insn->opcode, v.format, slot);
6555        slot++)
6556     {
6557       v.slots[slot].opcode =
6558         xtensa_format_slot_nop_opcode (isa, v.format, slot);
6559       v.slots[slot].ntok = 0;
6560       v.slots[slot].insn_type = ITYPE_INSN;
6561     }
6562
6563   v.slots[slot] = *orig_insn;
6564   slot++;
6565
6566   for ( ; slot < v.num_slots; slot++)
6567     {
6568       v.slots[slot].opcode =
6569         xtensa_format_slot_nop_opcode (isa, v.format, slot);
6570       v.slots[slot].ntok = 0;
6571       v.slots[slot].insn_type = ITYPE_INSN;
6572     }
6573
6574   finish_vinsn (&v);
6575   xg_free_vinsn (&v);
6576 }
6577
6578
6579 static bfd_boolean
6580 emit_single_op (TInsn *orig_insn)
6581 {
6582   int i;
6583   IStack istack;                /* put instructions into here */
6584   symbolS *lit_sym = NULL;
6585   symbolS *label_sym = NULL;
6586
6587   istack_init (&istack);
6588
6589   /* Special-case for "movi aX, foo" which is guaranteed to need relaxing.
6590      Because the scheduling and bundling characteristics of movi and
6591      l32r or const16 are so different, we can do much better if we relax
6592      it prior to scheduling and bundling, rather than after.  */
6593   if ((orig_insn->opcode == xtensa_movi_opcode
6594        || orig_insn->opcode == xtensa_movi_n_opcode)
6595       && !cur_vinsn.inside_bundle
6596       && (orig_insn->tok[1].X_op == O_symbol
6597           || orig_insn->tok[1].X_op == O_pltrel))
6598     xg_assembly_relax (&istack, orig_insn, now_seg, frag_now, 0, 1, 0);
6599   else
6600     if (xg_expand_assembly_insn (&istack, orig_insn))
6601       return TRUE;
6602
6603   for (i = 0; i < istack.ninsn; i++)
6604     {
6605       TInsn *insn = &istack.insn[i];
6606       switch (insn->insn_type)
6607         {
6608         case ITYPE_LITERAL:
6609           assert (lit_sym == NULL);
6610           lit_sym = xg_assemble_literal (insn);
6611           break;
6612         case ITYPE_LABEL:
6613           {
6614             static int relaxed_sym_idx = 0;
6615             char *label = xmalloc (strlen (FAKE_LABEL_NAME) + 12);
6616             sprintf (label, "%s_rl_%x", FAKE_LABEL_NAME, relaxed_sym_idx++);
6617             colon (label);
6618             assert (label_sym == NULL);
6619             label_sym = symbol_find_or_make (label);
6620             assert (label_sym);
6621             free (label);
6622           }
6623           break;
6624         case ITYPE_INSN:
6625           if (lit_sym)
6626             xg_resolve_literals (insn, lit_sym);
6627           if (label_sym)
6628             xg_resolve_labels (insn, label_sym);
6629           bundle_single_op (insn);
6630           break;
6631         default:
6632           assert (0);
6633           break;
6634         }
6635     }
6636   return FALSE;
6637 }
6638
6639
6640 static int
6641 total_frag_text_expansion (fragS *fragP)
6642 {
6643   int slot;
6644   int total_expansion = 0;
6645
6646   for (slot = 0; slot < MAX_SLOTS; slot++)
6647     total_expansion += fragP->tc_frag_data.text_expansion[slot];
6648
6649   return total_expansion;
6650 }
6651
6652
6653 /* Emit a vliw instruction to the current fragment.  */
6654
6655 static void
6656 xg_assemble_vliw_tokens (vliw_insn *vinsn)
6657 {
6658   bfd_boolean finish_frag = FALSE;
6659   bfd_boolean is_jump = FALSE;
6660   bfd_boolean is_branch = FALSE;
6661   xtensa_isa isa = xtensa_default_isa;
6662   int i;
6663   int insn_size;
6664   int extra_space;
6665   char *f = NULL;
6666   int slot;
6667   struct dwarf2_line_info best_loc;
6668
6669   best_loc.line = INT_MAX;
6670
6671   if (generating_literals)
6672     {
6673       static int reported = 0;
6674       if (reported < 4)
6675         as_bad_where (frag_now->fr_file, frag_now->fr_line,
6676                       _("cannot assemble into a literal fragment"));
6677       if (reported == 3)
6678         as_bad (_("..."));
6679       reported++;
6680       return;
6681     }
6682
6683   if (frag_now_fix () != 0
6684       && (! frag_now->tc_frag_data.is_insn
6685           || (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6686           || !use_transform () != frag_now->tc_frag_data.is_no_transform
6687           || (directive_state[directive_longcalls]
6688               != frag_now->tc_frag_data.use_longcalls)
6689           || (directive_state[directive_absolute_literals]
6690               != frag_now->tc_frag_data.use_absolute_literals)))
6691     {
6692       frag_wane (frag_now);
6693       frag_new (0);
6694       xtensa_set_frag_assembly_state (frag_now);
6695     }
6696
6697   if (workaround_a0_b_retw
6698       && vinsn->num_slots == 1
6699       && (get_last_insn_flags (now_seg, now_subseg) & FLAG_IS_A0_WRITER) != 0
6700       && xtensa_opcode_is_branch (isa, vinsn->slots[0].opcode) == 1
6701       && use_transform ())
6702     {
6703       has_a0_b_retw = TRUE;
6704
6705       /* Mark this fragment with the special RELAX_ADD_NOP_IF_A0_B_RETW.
6706          After the first assembly pass we will check all of them and
6707          add a nop if needed.  */
6708       frag_now->tc_frag_data.is_insn = TRUE;
6709       frag_var (rs_machine_dependent, 4, 4,
6710                 RELAX_ADD_NOP_IF_A0_B_RETW,
6711                 frag_now->fr_symbol,
6712                 frag_now->fr_offset,
6713                 NULL);
6714       xtensa_set_frag_assembly_state (frag_now);
6715       frag_now->tc_frag_data.is_insn = TRUE;
6716       frag_var (rs_machine_dependent, 4, 4,
6717                 RELAX_ADD_NOP_IF_A0_B_RETW,
6718                 frag_now->fr_symbol,
6719                 frag_now->fr_offset,
6720                 NULL);
6721       xtensa_set_frag_assembly_state (frag_now);
6722     }
6723
6724   for (i = 0; i < vinsn->num_slots; i++)
6725     {
6726       /* See if the instruction implies an aligned section.  */
6727       if (xtensa_opcode_is_loop (isa, vinsn->slots[i].opcode) == 1)
6728         record_alignment (now_seg, 2);
6729
6730       /* Also determine the best line number for debug info.  */
6731       best_loc = vinsn->slots[i].loc.line < best_loc.line
6732         ? vinsn->slots[i].loc : best_loc;
6733     }
6734
6735   /* Special cases for instructions that force an alignment... */
6736   /* None of these opcodes are bundle-able.  */
6737   if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode) == 1)
6738     {
6739       int max_fill;
6740
6741       xtensa_set_frag_assembly_state (frag_now);
6742       frag_now->tc_frag_data.is_insn = TRUE;
6743
6744       max_fill = get_text_align_max_fill_size
6745         (get_text_align_power (xtensa_fetch_width),
6746          TRUE, frag_now->tc_frag_data.is_no_density);
6747
6748       if (use_transform ())
6749         frag_var (rs_machine_dependent, max_fill, max_fill,
6750                   RELAX_ALIGN_NEXT_OPCODE,
6751                   frag_now->fr_symbol,
6752                   frag_now->fr_offset,
6753                   NULL);
6754       else
6755         frag_var (rs_machine_dependent, 0, 0,
6756                   RELAX_CHECK_ALIGN_NEXT_OPCODE, 0, 0, NULL);
6757       xtensa_set_frag_assembly_state (frag_now);
6758
6759       xtensa_move_labels (frag_now, 0, FALSE);
6760     }
6761
6762   if (vinsn->slots[0].opcode == xtensa_entry_opcode
6763       && !vinsn->slots[0].is_specific_opcode)
6764     {
6765       xtensa_mark_literal_pool_location ();
6766       xtensa_move_labels (frag_now, 0, TRUE);
6767       frag_var (rs_align_test, 1, 1, 0, NULL, 2, NULL);
6768     }
6769
6770   if (vinsn->num_slots == 1)
6771     {
6772       if (workaround_a0_b_retw && use_transform ())
6773         set_last_insn_flags (now_seg, now_subseg, FLAG_IS_A0_WRITER,
6774                              is_register_writer (&vinsn->slots[0], "a", 0));
6775
6776       set_last_insn_flags (now_seg, now_subseg, FLAG_IS_BAD_LOOPEND,
6777                            is_bad_loopend_opcode (&vinsn->slots[0]));
6778     }
6779   else
6780     set_last_insn_flags (now_seg, now_subseg, FLAG_IS_BAD_LOOPEND, FALSE);
6781
6782   insn_size = xtensa_format_length (isa, vinsn->format);
6783
6784   extra_space = relaxation_requirements (vinsn);
6785
6786   /* vinsn_to_insnbuf will produce the error.  */
6787   if (vinsn->format != XTENSA_UNDEFINED)
6788     {
6789       f = frag_more (insn_size + extra_space);
6790       xtensa_set_frag_assembly_state (frag_now);
6791       frag_now->tc_frag_data.is_insn = TRUE;
6792     }
6793
6794   vinsn_to_insnbuf (vinsn, f, frag_now, TRUE);
6795   if (vinsn->format == XTENSA_UNDEFINED)
6796     return;
6797
6798   xtensa_insnbuf_to_chars (isa, vinsn->insnbuf, (unsigned char *) f, 0);
6799
6800   xtensa_dwarf2_emit_insn (insn_size + extra_space, &best_loc);
6801
6802   for (slot = 0; slot < vinsn->num_slots; slot++)
6803     {
6804       TInsn *tinsn = &vinsn->slots[slot];
6805       frag_now->tc_frag_data.slot_subtypes[slot] = tinsn->subtype;
6806       frag_now->tc_frag_data.slot_symbols[slot] = tinsn->symbol;
6807       frag_now->tc_frag_data.slot_sub_symbols[slot] = tinsn->sub_symbol;
6808       frag_now->tc_frag_data.slot_offsets[slot] = tinsn->offset;
6809       frag_now->tc_frag_data.literal_frags[slot] = tinsn->literal_frag;
6810       if (tinsn->literal_space != 0)
6811         xg_assemble_literal_space (tinsn->literal_space, slot);
6812
6813       if (tinsn->subtype == RELAX_NARROW)
6814         assert (vinsn->num_slots == 1);
6815       if (xtensa_opcode_is_jump (isa, tinsn->opcode) == 1)
6816         is_jump = TRUE;
6817       if (xtensa_opcode_is_branch (isa, tinsn->opcode) == 1)
6818         is_branch = TRUE;
6819
6820       if (tinsn->subtype || tinsn->symbol || tinsn->record_fix
6821           || tinsn->offset || tinsn->literal_frag || is_jump || is_branch)
6822         finish_frag = TRUE;
6823     }
6824
6825   if (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6826     frag_now->tc_frag_data.is_specific_opcode = TRUE;
6827
6828   if (finish_frag)
6829     {
6830       frag_variant (rs_machine_dependent,
6831                     extra_space, extra_space, RELAX_SLOTS,
6832                     frag_now->fr_symbol, frag_now->fr_offset, f);
6833       xtensa_set_frag_assembly_state (frag_now);
6834     }
6835
6836   /* Special cases for loops:
6837      close_loop_end should be inserted AFTER short_loop.
6838      Make sure that CLOSE loops are processed BEFORE short_loops
6839      when converting them.  */
6840
6841   /* "short_loop": Add a NOP if the loop is < 4 bytes.  */
6842   if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode)
6843       && !vinsn->slots[0].is_specific_opcode)
6844     {
6845       if (workaround_short_loop && use_transform ())
6846         {
6847           maybe_has_short_loop = TRUE;
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           frag_now->tc_frag_data.is_insn = TRUE;
6853           frag_var (rs_machine_dependent, 4, 4,
6854                     RELAX_ADD_NOP_IF_SHORT_LOOP,
6855                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6856         }
6857
6858       /* "close_loop_end": Add up to 12 bytes of NOPs to keep a
6859          loop at least 12 bytes away from another loop's end.  */
6860       if (workaround_close_loop_end && use_transform ())
6861         {
6862           maybe_has_close_loop_end = TRUE;
6863           frag_now->tc_frag_data.is_insn = TRUE;
6864           frag_var (rs_machine_dependent, 12, 12,
6865                     RELAX_ADD_NOP_IF_CLOSE_LOOP_END,
6866                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6867         }
6868     }
6869
6870   if (use_transform ())
6871     {
6872       if (is_jump)
6873         {
6874           assert (finish_frag);
6875           frag_var (rs_machine_dependent,
6876                     UNREACHABLE_MAX_WIDTH, UNREACHABLE_MAX_WIDTH,
6877                     RELAX_UNREACHABLE,
6878                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6879           xtensa_set_frag_assembly_state (frag_now);
6880         }
6881       else if (is_branch && do_align_targets ())
6882         {
6883           assert (finish_frag);
6884           frag_var (rs_machine_dependent,
6885                     UNREACHABLE_MAX_WIDTH, UNREACHABLE_MAX_WIDTH,
6886                     RELAX_MAYBE_UNREACHABLE,
6887                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6888           xtensa_set_frag_assembly_state (frag_now);
6889           frag_var (rs_machine_dependent,
6890                     0, 0,
6891                     RELAX_MAYBE_DESIRE_ALIGN,
6892                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6893           xtensa_set_frag_assembly_state (frag_now);
6894         }
6895     }
6896
6897   /* Now, if the original opcode was a call...  */
6898   if (do_align_targets ()
6899       && xtensa_opcode_is_call (isa, vinsn->slots[0].opcode) == 1)
6900     {
6901       float freq = get_subseg_total_freq (now_seg, now_subseg);
6902       frag_now->tc_frag_data.is_insn = TRUE;
6903       frag_var (rs_machine_dependent, 4, (int) freq, RELAX_DESIRE_ALIGN,
6904                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
6905       xtensa_set_frag_assembly_state (frag_now);
6906     }
6907
6908   if (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6909     {
6910       frag_wane (frag_now);
6911       frag_new (0);
6912       xtensa_set_frag_assembly_state (frag_now);
6913     }
6914 }
6915
6916 \f
6917 /* xtensa_end and helper functions.  */
6918
6919 static void xtensa_cleanup_align_frags (void);
6920 static void xtensa_fix_target_frags (void);
6921 static void xtensa_mark_narrow_branches (void);
6922 static void xtensa_mark_zcl_first_insns (void);
6923 static void xtensa_fix_a0_b_retw_frags (void);
6924 static void xtensa_fix_b_j_loop_end_frags (void);
6925 static void xtensa_fix_close_loop_end_frags (void);
6926 static void xtensa_fix_short_loop_frags (void);
6927 static void xtensa_sanity_check (void);
6928
6929 void
6930 xtensa_end (void)
6931 {
6932   directive_balance ();
6933   xtensa_flush_pending_output ();
6934
6935   past_xtensa_end = TRUE;
6936
6937   xtensa_move_literals ();
6938
6939   xtensa_reorder_segments ();
6940   xtensa_cleanup_align_frags ();
6941   xtensa_fix_target_frags ();
6942   if (workaround_a0_b_retw && has_a0_b_retw)
6943     xtensa_fix_a0_b_retw_frags ();
6944   if (workaround_b_j_loop_end)
6945     xtensa_fix_b_j_loop_end_frags ();
6946
6947   /* "close_loop_end" should be processed BEFORE "short_loop".  */
6948   if (workaround_close_loop_end && maybe_has_close_loop_end)
6949     xtensa_fix_close_loop_end_frags ();
6950
6951   if (workaround_short_loop && maybe_has_short_loop)
6952     xtensa_fix_short_loop_frags ();
6953   xtensa_mark_narrow_branches ();
6954   xtensa_mark_zcl_first_insns ();
6955
6956   xtensa_sanity_check ();
6957 }
6958
6959
6960 static void
6961 xtensa_cleanup_align_frags (void)
6962 {
6963   frchainS *frchP;
6964
6965   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
6966     {
6967       fragS *fragP;
6968       /* Walk over all of the fragments in a subsection.  */
6969       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
6970         {
6971           if ((fragP->fr_type == rs_align
6972                || fragP->fr_type == rs_align_code
6973                || (fragP->fr_type == rs_machine_dependent
6974                    && (fragP->fr_subtype == RELAX_DESIRE_ALIGN
6975                        || fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)))
6976               && fragP->fr_fix == 0)
6977             {
6978               fragS *next = fragP->fr_next;
6979
6980               while (next
6981                      && next->fr_fix == 0
6982                      && next->fr_type == rs_machine_dependent
6983                      && next->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)
6984                 {
6985                   frag_wane (next);
6986                   next = next->fr_next;
6987                 }
6988             }
6989           /* If we don't widen branch targets, then they
6990              will be easier to align.  */
6991           if (fragP->tc_frag_data.is_branch_target
6992               && fragP->fr_opcode == fragP->fr_literal
6993               && fragP->fr_type == rs_machine_dependent
6994               && fragP->fr_subtype == RELAX_SLOTS
6995               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
6996             frag_wane (fragP);
6997           if (fragP->fr_type == rs_machine_dependent
6998               && fragP->fr_subtype == RELAX_UNREACHABLE)
6999             fragP->tc_frag_data.is_unreachable = TRUE;
7000         }
7001     }
7002 }
7003
7004
7005 /* Re-process all of the fragments looking to convert all of the
7006    RELAX_DESIRE_ALIGN_IF_TARGET fragments.  If there is a branch
7007    target in the next fragment, convert this to RELAX_DESIRE_ALIGN.
7008    Otherwise, convert to a .fill 0.  */
7009
7010 static void
7011 xtensa_fix_target_frags (void)
7012 {
7013   frchainS *frchP;
7014
7015   /* When this routine is called, all of the subsections are still intact
7016      so we walk over subsections instead of sections.  */
7017   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7018     {
7019       fragS *fragP;
7020
7021       /* Walk over all of the fragments in a subsection.  */
7022       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7023         {
7024           if (fragP->fr_type == rs_machine_dependent
7025               && fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)
7026             {
7027               if (next_frag_is_branch_target (fragP))
7028                 fragP->fr_subtype = RELAX_DESIRE_ALIGN;
7029               else
7030                 frag_wane (fragP);
7031             }
7032         }
7033     }
7034 }
7035
7036
7037 static bfd_boolean is_narrow_branch_guaranteed_in_range (fragS *, TInsn *);
7038
7039 static void
7040 xtensa_mark_narrow_branches (void)
7041 {
7042   frchainS *frchP;
7043
7044   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7045     {
7046       fragS *fragP;
7047       /* Walk over all of the fragments in a subsection.  */
7048       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7049         {
7050           if (fragP->fr_type == rs_machine_dependent
7051               && fragP->fr_subtype == RELAX_SLOTS
7052               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED)
7053             {
7054               vliw_insn vinsn;
7055               const expressionS *expr;
7056               symbolS *symbolP;
7057
7058               vinsn_from_chars (&vinsn, fragP->fr_opcode);
7059               tinsn_immed_from_frag (&vinsn.slots[0], fragP, 0);
7060
7061               expr = &vinsn.slots[0].tok[1];
7062               symbolP = expr->X_add_symbol;
7063
7064               if (vinsn.num_slots == 1
7065                   && xtensa_opcode_is_branch (xtensa_default_isa,
7066                                               vinsn.slots[0].opcode)
7067                   && xg_get_single_size (vinsn.slots[0].opcode) == 2
7068                   && is_narrow_branch_guaranteed_in_range (fragP,
7069                                                            &vinsn.slots[0]))
7070                 {
7071                   fragP->fr_subtype = RELAX_SLOTS;
7072                   fragP->tc_frag_data.slot_subtypes[0] = RELAX_NARROW;
7073                 }
7074             }
7075         }
7076     }
7077 }
7078
7079
7080 /* A branch is typically widened only when its target is out of
7081    range.  However, we would like to widen them to align a subsequent
7082    branch target when possible.
7083
7084    Because the branch relaxation code is so convoluted, the optimal solution
7085    (combining the two cases) is difficult to get right in all circumstances.
7086    We therefore go with an "almost as good" solution, where we only
7087    use for alignment narrow branches that definitely will not expand to a
7088    jump and a branch.  These functions find and mark these cases.  */
7089
7090 /* The range in bytes of BNEZ.N and BEQZ.N.  The target operand is encoded
7091    as PC + 4 + imm6, where imm6 is a 6-bit immediate ranging from 0 to 63.
7092    We start counting beginning with the frag after the 2-byte branch, so the
7093    maximum offset is (4 - 2) + 63 = 65.  */
7094 #define MAX_IMMED6 65
7095
7096 static offsetT unrelaxed_frag_max_size (fragS *);
7097
7098 static bfd_boolean
7099 is_narrow_branch_guaranteed_in_range (fragS *fragP, TInsn *tinsn)
7100 {
7101   const expressionS *expr = &tinsn->tok[1];
7102   symbolS *symbolP = expr->X_add_symbol;
7103   fragS *target_frag = symbol_get_frag (symbolP);
7104   offsetT max_distance = expr->X_add_number;
7105   max_distance += (S_GET_VALUE (symbolP) - target_frag->fr_address);
7106   if (is_branch_jmp_to_next (tinsn, fragP))
7107     return FALSE;
7108
7109   /* The branch doesn't branch over it's own frag,
7110      but over the subsequent ones.  */
7111   fragP = fragP->fr_next;
7112   while (fragP != NULL && fragP != target_frag && max_distance <= MAX_IMMED6)
7113     {
7114       max_distance += unrelaxed_frag_max_size (fragP);
7115       fragP = fragP->fr_next;
7116     }
7117   if (max_distance <= MAX_IMMED6 && fragP == target_frag)
7118     return TRUE;
7119   return FALSE;
7120 }
7121
7122
7123 static void
7124 xtensa_mark_zcl_first_insns (void)
7125 {
7126   frchainS *frchP;
7127
7128   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7129     {
7130       fragS *fragP;
7131       /* Walk over all of the fragments in a subsection.  */
7132       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7133         {
7134           if (fragP->fr_type == rs_machine_dependent
7135               && (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE
7136                   || fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE))
7137             {
7138               /* Find the loop frag.  */
7139               fragS *targ_frag = next_non_empty_frag (fragP);
7140               /* Find the first insn frag.  */
7141               targ_frag = next_non_empty_frag (targ_frag);
7142
7143               /* Of course, sometimes (mostly for toy test cases) a
7144                  zero-cost loop instruction is the last in a section.  */
7145               if (targ_frag)
7146                 targ_frag->tc_frag_data.is_first_loop_insn = TRUE;
7147               if (fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE)
7148                 frag_wane (fragP);
7149             }
7150         }
7151     }
7152 }
7153
7154
7155 /* Re-process all of the fragments looking to convert all of the
7156    RELAX_ADD_NOP_IF_A0_B_RETW.  If the next instruction is a
7157    conditional branch or a retw/retw.n, convert this frag to one that
7158    will generate a NOP.  In any case close it off with a .fill 0.  */
7159
7160 static bfd_boolean next_instrs_are_b_retw (fragS *);
7161
7162 static void
7163 xtensa_fix_a0_b_retw_frags (void)
7164 {
7165   frchainS *frchP;
7166
7167   /* When this routine is called, all of the subsections are still intact
7168      so we walk over subsections instead of sections.  */
7169   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7170     {
7171       fragS *fragP;
7172
7173       /* Walk over all of the fragments in a subsection.  */
7174       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7175         {
7176           if (fragP->fr_type == rs_machine_dependent
7177               && fragP->fr_subtype == RELAX_ADD_NOP_IF_A0_B_RETW)
7178             {
7179               if (next_instrs_are_b_retw (fragP))
7180                 {
7181                   if (fragP->tc_frag_data.is_no_transform)
7182                     as_bad (_("instruction sequence (write a0, branch, retw) may trigger hardware errata"));
7183                   else
7184                     relax_frag_add_nop (fragP);
7185                 }
7186               frag_wane (fragP);
7187             }
7188         }
7189     }
7190 }
7191
7192
7193 static bfd_boolean
7194 next_instrs_are_b_retw (fragS *fragP)
7195 {
7196   xtensa_opcode opcode;
7197   xtensa_format fmt;
7198   const fragS *next_fragP = next_non_empty_frag (fragP);
7199   static xtensa_insnbuf insnbuf = NULL;
7200   static xtensa_insnbuf slotbuf = NULL;
7201   xtensa_isa isa = xtensa_default_isa;
7202   int offset = 0;
7203   int slot;
7204   bfd_boolean branch_seen = FALSE;
7205
7206   if (!insnbuf)
7207     {
7208       insnbuf = xtensa_insnbuf_alloc (isa);
7209       slotbuf = xtensa_insnbuf_alloc (isa);
7210     }
7211
7212   if (next_fragP == NULL)
7213     return FALSE;
7214
7215   /* Check for the conditional branch.  */
7216   xtensa_insnbuf_from_chars
7217     (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
7218   fmt = xtensa_format_decode (isa, insnbuf);
7219   if (fmt == XTENSA_UNDEFINED)
7220     return FALSE;
7221
7222   for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
7223     {
7224       xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
7225       opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
7226
7227       branch_seen = (branch_seen
7228                      || xtensa_opcode_is_branch (isa, opcode) == 1);
7229     }
7230
7231   if (!branch_seen)
7232     return FALSE;
7233
7234   offset += xtensa_format_length (isa, fmt);
7235   if (offset == next_fragP->fr_fix)
7236     {
7237       next_fragP = next_non_empty_frag (next_fragP);
7238       offset = 0;
7239     }
7240
7241   if (next_fragP == NULL)
7242     return FALSE;
7243
7244   /* Check for the retw/retw.n.  */
7245   xtensa_insnbuf_from_chars
7246     (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
7247   fmt = xtensa_format_decode (isa, insnbuf);
7248
7249   /* Because RETW[.N] is not bundleable, a VLIW bundle here means that we
7250      have no problems.  */
7251   if (fmt == XTENSA_UNDEFINED
7252       || xtensa_format_num_slots (isa, fmt) != 1)
7253     return FALSE;
7254
7255   xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7256   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7257
7258   if (opcode == xtensa_retw_opcode || opcode == xtensa_retw_n_opcode)
7259     return TRUE;
7260
7261   return FALSE;
7262 }
7263
7264
7265 /* Re-process all of the fragments looking to convert all of the
7266    RELAX_ADD_NOP_IF_PRE_LOOP_END.  If there is one instruction and a
7267    loop end label, convert this frag to one that will generate a NOP.
7268    In any case close it off with a .fill 0.  */
7269
7270 static bfd_boolean next_instr_is_loop_end (fragS *);
7271
7272 static void
7273 xtensa_fix_b_j_loop_end_frags (void)
7274 {
7275   frchainS *frchP;
7276
7277   /* When this routine is called, all of the subsections are still intact
7278      so we walk over subsections instead of sections.  */
7279   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7280     {
7281       fragS *fragP;
7282
7283       /* Walk over all of the fragments in a subsection.  */
7284       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7285         {
7286           if (fragP->fr_type == rs_machine_dependent
7287               && fragP->fr_subtype == RELAX_ADD_NOP_IF_PRE_LOOP_END)
7288             {
7289               if (next_instr_is_loop_end (fragP))
7290                 {
7291                   if (fragP->tc_frag_data.is_no_transform)
7292                     as_bad (_("branching or jumping to a loop end may trigger hardware errata"));
7293                   else
7294                     relax_frag_add_nop (fragP);
7295                 }
7296               frag_wane (fragP);
7297             }
7298         }
7299     }
7300 }
7301
7302
7303 static bfd_boolean
7304 next_instr_is_loop_end (fragS *fragP)
7305 {
7306   const fragS *next_fragP;
7307
7308   if (next_frag_is_loop_target (fragP))
7309     return FALSE;
7310
7311   next_fragP = next_non_empty_frag (fragP);
7312   if (next_fragP == NULL)
7313     return FALSE;
7314
7315   if (!next_frag_is_loop_target (next_fragP))
7316     return FALSE;
7317
7318   /* If the size is >= 3 then there is more than one instruction here.
7319      The hardware bug will not fire.  */
7320   if (next_fragP->fr_fix > 3)
7321     return FALSE;
7322
7323   return TRUE;
7324 }
7325
7326
7327 /* Re-process all of the fragments looking to convert all of the
7328    RELAX_ADD_NOP_IF_CLOSE_LOOP_END.  If there is an loop end that is
7329    not MY loop's loop end within 12 bytes, add enough nops here to
7330    make it at least 12 bytes away.  In any case close it off with a
7331    .fill 0.  */
7332
7333 static offsetT min_bytes_to_other_loop_end
7334   (fragS *, fragS *, offsetT, offsetT);
7335
7336 static void
7337 xtensa_fix_close_loop_end_frags (void)
7338 {
7339   frchainS *frchP;
7340
7341   /* When this routine is called, all of the subsections are still intact
7342      so we walk over subsections instead of sections.  */
7343   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7344     {
7345       fragS *fragP;
7346
7347       fragS *current_target = NULL;
7348       offsetT current_offset = 0;
7349
7350       /* Walk over all of the fragments in a subsection.  */
7351       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7352         {
7353           if (fragP->fr_type == rs_machine_dependent
7354               && ((fragP->fr_subtype == RELAX_IMMED)
7355                   || ((fragP->fr_subtype == RELAX_SLOTS)
7356                       && (fragP->tc_frag_data.slot_subtypes[0]
7357                           == RELAX_IMMED))))
7358             {
7359               /* Read it.  If the instruction is a loop, get the target.  */
7360               TInsn t_insn;
7361               tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7362               if (xtensa_opcode_is_loop (xtensa_default_isa,
7363                                          t_insn.opcode) == 1)
7364                 {
7365                   /* Get the current fragment target.  */
7366                   if (fragP->tc_frag_data.slot_symbols[0])
7367                     {
7368                       symbolS *sym = fragP->tc_frag_data.slot_symbols[0];
7369                       current_target = symbol_get_frag (sym);
7370                       current_offset = fragP->fr_offset;
7371                     }
7372                 }
7373             }
7374
7375           if (current_target
7376               && fragP->fr_type == rs_machine_dependent
7377               && fragP->fr_subtype == RELAX_ADD_NOP_IF_CLOSE_LOOP_END)
7378             {
7379               offsetT min_bytes;
7380               int bytes_added = 0;
7381
7382 #define REQUIRED_LOOP_DIVIDING_BYTES 12
7383               /* Max out at 12.  */
7384               min_bytes = min_bytes_to_other_loop_end
7385                 (fragP->fr_next, current_target, current_offset,
7386                  REQUIRED_LOOP_DIVIDING_BYTES);
7387
7388               if (min_bytes < REQUIRED_LOOP_DIVIDING_BYTES)
7389                 {
7390                   if (fragP->tc_frag_data.is_no_transform)
7391                     as_bad (_("loop end too close to another loop end may trigger hardware errata"));
7392                   else
7393                     {
7394                       while (min_bytes + bytes_added
7395                              < REQUIRED_LOOP_DIVIDING_BYTES)
7396                         {
7397                           int length = 3;
7398
7399                           if (fragP->fr_var < length)
7400                             as_fatal (_("fr_var %lu < length %d"),
7401                                       (long) fragP->fr_var, length);
7402                           else
7403                             {
7404                               assemble_nop (length,
7405                                             fragP->fr_literal + fragP->fr_fix);
7406                               fragP->fr_fix += length;
7407                               fragP->fr_var -= length;
7408                             }
7409                           bytes_added += length;
7410                         }
7411                     }
7412                 }
7413               frag_wane (fragP);
7414             }
7415           assert (fragP->fr_type != rs_machine_dependent
7416                   || fragP->fr_subtype != RELAX_ADD_NOP_IF_CLOSE_LOOP_END);
7417         }
7418     }
7419 }
7420
7421
7422 static offsetT unrelaxed_frag_min_size (fragS *);
7423
7424 static offsetT
7425 min_bytes_to_other_loop_end (fragS *fragP,
7426                              fragS *current_target,
7427                              offsetT current_offset,
7428                              offsetT max_size)
7429 {
7430   offsetT offset = 0;
7431   fragS *current_fragP;
7432
7433   for (current_fragP = fragP;
7434        current_fragP;
7435        current_fragP = current_fragP->fr_next)
7436     {
7437       if (current_fragP->tc_frag_data.is_loop_target
7438           && current_fragP != current_target)
7439         return offset + current_offset;
7440
7441       offset += unrelaxed_frag_min_size (current_fragP);
7442
7443       if (offset + current_offset >= max_size)
7444         return max_size;
7445     }
7446   return max_size;
7447 }
7448
7449
7450 static offsetT
7451 unrelaxed_frag_min_size (fragS *fragP)
7452 {
7453   offsetT size = fragP->fr_fix;
7454
7455   /* Add fill size.  */
7456   if (fragP->fr_type == rs_fill)
7457     size += fragP->fr_offset;
7458
7459   return size;
7460 }
7461
7462
7463 static offsetT
7464 unrelaxed_frag_max_size (fragS *fragP)
7465 {
7466   offsetT size = fragP->fr_fix;
7467   switch (fragP->fr_type)
7468     {
7469     case 0:
7470       /* Empty frags created by the obstack allocation scheme
7471          end up with type 0.  */
7472       break;
7473     case rs_fill:
7474     case rs_org:
7475     case rs_space:
7476       size += fragP->fr_offset;
7477       break;
7478     case rs_align:
7479     case rs_align_code:
7480     case rs_align_test:
7481     case rs_leb128:
7482     case rs_cfa:
7483     case rs_dwarf2dbg:
7484       /* No further adjustments needed.  */
7485       break;
7486     case rs_machine_dependent:
7487       if (fragP->fr_subtype != RELAX_DESIRE_ALIGN)
7488         size += fragP->fr_var;
7489       break;
7490     default:
7491       /* We had darn well better know how big it is.  */
7492       assert (0);
7493       break;
7494     }
7495
7496   return size;
7497 }
7498
7499
7500 /* Re-process all of the fragments looking to convert all
7501    of the RELAX_ADD_NOP_IF_SHORT_LOOP.  If:
7502
7503    A)
7504      1) the instruction size count to the loop end label
7505         is too short (<= 2 instructions),
7506      2) loop has a jump or branch in it
7507
7508    or B)
7509      1) workaround_all_short_loops is TRUE
7510      2) The generating loop was a  'loopgtz' or 'loopnez'
7511      3) the instruction size count to the loop end label is too short
7512         (<= 2 instructions)
7513    then convert this frag (and maybe the next one) to generate a NOP.
7514    In any case close it off with a .fill 0.  */
7515
7516 static int count_insns_to_loop_end (fragS *, bfd_boolean, int);
7517 static bfd_boolean branch_before_loop_end (fragS *);
7518
7519 static void
7520 xtensa_fix_short_loop_frags (void)
7521 {
7522   frchainS *frchP;
7523
7524   /* When this routine is called, all of the subsections are still intact
7525      so we walk over subsections instead of sections.  */
7526   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7527     {
7528       fragS *fragP;
7529       fragS *current_target = NULL;
7530       offsetT current_offset = 0;
7531       xtensa_opcode current_opcode = XTENSA_UNDEFINED;
7532
7533       /* Walk over all of the fragments in a subsection.  */
7534       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7535         {
7536           /* Check on the current loop.  */
7537           if (fragP->fr_type == rs_machine_dependent
7538               && ((fragP->fr_subtype == RELAX_IMMED)
7539                   || ((fragP->fr_subtype == RELAX_SLOTS)
7540                       && (fragP->tc_frag_data.slot_subtypes[0]
7541                           == RELAX_IMMED))))
7542             {
7543               TInsn t_insn;
7544
7545               /* Read it.  If the instruction is a loop, get the target.  */
7546               tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7547               if (xtensa_opcode_is_loop (xtensa_default_isa,
7548                                          t_insn.opcode) == 1)
7549                 {
7550                   /* Get the current fragment target.  */
7551                   if (fragP->tc_frag_data.slot_symbols[0])
7552                     {
7553                       symbolS *sym = fragP->tc_frag_data.slot_symbols[0];
7554                       current_target = symbol_get_frag (sym);
7555                       current_offset = fragP->fr_offset;
7556                       current_opcode = t_insn.opcode;
7557                     }
7558                 }
7559             }
7560
7561           if (fragP->fr_type == rs_machine_dependent
7562               && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP)
7563             {
7564               if (count_insns_to_loop_end (fragP->fr_next, TRUE, 3) < 3
7565                   && (branch_before_loop_end (fragP->fr_next)
7566                       || (workaround_all_short_loops
7567                           && current_opcode != XTENSA_UNDEFINED
7568                           && current_opcode != xtensa_loop_opcode)))
7569                 {
7570                   if (fragP->tc_frag_data.is_no_transform)
7571                     as_bad (_("loop containing less than three instructions may trigger hardware errata"));
7572                   else
7573                     relax_frag_add_nop (fragP);
7574                 }
7575               frag_wane (fragP);
7576             }
7577         }
7578     }
7579 }
7580
7581
7582 static int unrelaxed_frag_min_insn_count (fragS *);
7583
7584 static int
7585 count_insns_to_loop_end (fragS *base_fragP,
7586                          bfd_boolean count_relax_add,
7587                          int max_count)
7588 {
7589   fragS *fragP = NULL;
7590   int insn_count = 0;
7591
7592   fragP = base_fragP;
7593
7594   for (; fragP && !fragP->tc_frag_data.is_loop_target; fragP = fragP->fr_next)
7595     {
7596       insn_count += unrelaxed_frag_min_insn_count (fragP);
7597       if (insn_count >= max_count)
7598         return max_count;
7599
7600       if (count_relax_add)
7601         {
7602           if (fragP->fr_type == rs_machine_dependent
7603               && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP)
7604             {
7605               /* In order to add the appropriate number of
7606                  NOPs, we count an instruction for downstream
7607                  occurrences.  */
7608               insn_count++;
7609               if (insn_count >= max_count)
7610                 return max_count;
7611             }
7612         }
7613     }
7614   return insn_count;
7615 }
7616
7617
7618 static int
7619 unrelaxed_frag_min_insn_count (fragS *fragP)
7620 {
7621   xtensa_isa isa = xtensa_default_isa;
7622   static xtensa_insnbuf insnbuf = NULL;
7623   int insn_count = 0;
7624   int offset = 0;
7625
7626   if (!fragP->tc_frag_data.is_insn)
7627     return insn_count;
7628
7629   if (!insnbuf)
7630     insnbuf = xtensa_insnbuf_alloc (isa);
7631
7632   /* Decode the fixed instructions.  */
7633   while (offset < fragP->fr_fix)
7634     {
7635       xtensa_format fmt;
7636
7637       xtensa_insnbuf_from_chars
7638         (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
7639       fmt = xtensa_format_decode (isa, insnbuf);
7640
7641       if (fmt == XTENSA_UNDEFINED)
7642         {
7643           as_fatal (_("undecodable instruction in instruction frag"));
7644           return insn_count;
7645         }
7646       offset += xtensa_format_length (isa, fmt);
7647       insn_count++;
7648     }
7649
7650   return insn_count;
7651 }
7652
7653
7654 static bfd_boolean unrelaxed_frag_has_b_j (fragS *);
7655
7656 static bfd_boolean
7657 branch_before_loop_end (fragS *base_fragP)
7658 {
7659   fragS *fragP;
7660
7661   for (fragP = base_fragP;
7662        fragP && !fragP->tc_frag_data.is_loop_target;
7663        fragP = fragP->fr_next)
7664     {
7665       if (unrelaxed_frag_has_b_j (fragP))
7666         return TRUE;
7667     }
7668   return FALSE;
7669 }
7670
7671
7672 static bfd_boolean
7673 unrelaxed_frag_has_b_j (fragS *fragP)
7674 {
7675   static xtensa_insnbuf insnbuf = NULL;
7676   xtensa_isa isa = xtensa_default_isa;
7677   int offset = 0;
7678
7679   if (!fragP->tc_frag_data.is_insn)
7680     return FALSE;
7681
7682   if (!insnbuf)
7683     insnbuf = xtensa_insnbuf_alloc (isa);
7684
7685   /* Decode the fixed instructions.  */
7686   while (offset < fragP->fr_fix)
7687     {
7688       xtensa_format fmt;
7689       int slot;
7690
7691       xtensa_insnbuf_from_chars
7692         (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
7693       fmt = xtensa_format_decode (isa, insnbuf);
7694       if (fmt == XTENSA_UNDEFINED)
7695         return FALSE;
7696
7697       for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
7698         {
7699           xtensa_opcode opcode =
7700             get_opcode_from_buf (fragP->fr_literal + offset, slot);
7701           if (xtensa_opcode_is_branch (isa, opcode) == 1
7702               || xtensa_opcode_is_jump (isa, opcode) == 1)
7703             return TRUE;
7704         }
7705       offset += xtensa_format_length (isa, fmt);
7706     }
7707   return FALSE;
7708 }
7709
7710
7711 /* Checks to be made after initial assembly but before relaxation.  */
7712
7713 static bfd_boolean is_empty_loop (const TInsn *, fragS *);
7714 static bfd_boolean is_local_forward_loop (const TInsn *, fragS *);
7715
7716 static void
7717 xtensa_sanity_check (void)
7718 {
7719   char *file_name;
7720   unsigned line;
7721
7722   frchainS *frchP;
7723
7724   as_where (&file_name, &line);
7725   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7726     {
7727       fragS *fragP;
7728
7729       /* Walk over all of the fragments in a subsection.  */
7730       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7731         {
7732           /* Currently we only check for empty loops here.  */
7733           if (fragP->fr_type == rs_machine_dependent
7734               && fragP->fr_subtype == RELAX_IMMED)
7735             {
7736               static xtensa_insnbuf insnbuf = NULL;
7737               TInsn t_insn;
7738
7739               if (fragP->fr_opcode != NULL)
7740                 {
7741                   if (!insnbuf)
7742                     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
7743                   tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7744                   tinsn_immed_from_frag (&t_insn, fragP, 0);
7745
7746                   if (xtensa_opcode_is_loop (xtensa_default_isa,
7747                                              t_insn.opcode) == 1)
7748                     {
7749                       if (is_empty_loop (&t_insn, fragP))
7750                         {
7751                           new_logical_line (fragP->fr_file, fragP->fr_line);
7752                           as_bad (_("invalid empty loop"));
7753                         }
7754                       if (!is_local_forward_loop (&t_insn, fragP))
7755                         {
7756                           new_logical_line (fragP->fr_file, fragP->fr_line);
7757                           as_bad (_("loop target does not follow "
7758                                     "loop instruction in section"));
7759                         }
7760                     }
7761                 }
7762             }
7763         }
7764     }
7765   new_logical_line (file_name, line);
7766 }
7767
7768
7769 #define LOOP_IMMED_OPN 1
7770
7771 /* Return TRUE if the loop target is the next non-zero fragment.  */
7772
7773 static bfd_boolean
7774 is_empty_loop (const TInsn *insn, fragS *fragP)
7775 {
7776   const expressionS *expr;
7777   symbolS *symbolP;
7778   fragS *next_fragP;
7779
7780   if (insn->insn_type != ITYPE_INSN)
7781     return FALSE;
7782
7783   if (xtensa_opcode_is_loop (xtensa_default_isa, insn->opcode) != 1)
7784     return FALSE;
7785
7786   if (insn->ntok <= LOOP_IMMED_OPN)
7787     return FALSE;
7788
7789   expr = &insn->tok[LOOP_IMMED_OPN];
7790
7791   if (expr->X_op != O_symbol)
7792     return FALSE;
7793
7794   symbolP = expr->X_add_symbol;
7795   if (!symbolP)
7796     return FALSE;
7797
7798   if (symbol_get_frag (symbolP) == NULL)
7799     return FALSE;
7800
7801   if (S_GET_VALUE (symbolP) != 0)
7802     return FALSE;
7803
7804   /* Walk through the zero-size fragments from this one.  If we find
7805      the target fragment, then this is a zero-size loop.  */
7806
7807   for (next_fragP = fragP->fr_next;
7808        next_fragP != NULL;
7809        next_fragP = next_fragP->fr_next)
7810     {
7811       if (next_fragP == symbol_get_frag (symbolP))
7812         return TRUE;
7813       if (next_fragP->fr_fix != 0)
7814         return FALSE;
7815     }
7816   return FALSE;
7817 }
7818
7819
7820 static bfd_boolean
7821 is_local_forward_loop (const TInsn *insn, fragS *fragP)
7822 {
7823   const expressionS *expr;
7824   symbolS *symbolP;
7825   fragS *next_fragP;
7826
7827   if (insn->insn_type != ITYPE_INSN)
7828     return FALSE;
7829
7830   if (xtensa_opcode_is_loop (xtensa_default_isa, insn->opcode) == 0)
7831     return FALSE;
7832
7833   if (insn->ntok <= LOOP_IMMED_OPN)
7834     return FALSE;
7835
7836   expr = &insn->tok[LOOP_IMMED_OPN];
7837
7838   if (expr->X_op != O_symbol)
7839     return FALSE;
7840
7841   symbolP = expr->X_add_symbol;
7842   if (!symbolP)
7843     return FALSE;
7844
7845   if (symbol_get_frag (symbolP) == NULL)
7846     return FALSE;
7847
7848   /* Walk through fragments until we find the target.
7849      If we do not find the target, then this is an invalid loop.  */
7850
7851   for (next_fragP = fragP->fr_next;
7852        next_fragP != NULL;
7853        next_fragP = next_fragP->fr_next)
7854     {
7855       if (next_fragP == symbol_get_frag (symbolP))
7856         return TRUE;
7857     }
7858
7859   return FALSE;
7860 }
7861
7862 \f
7863 /* Alignment Functions.  */
7864
7865 static int
7866 get_text_align_power (unsigned target_size)
7867 {
7868   int i = 0;
7869   unsigned power = 1;
7870
7871   assert (target_size <= INT_MAX);
7872   while (target_size > power)
7873     {
7874       power <<= 1;
7875       i += 1;
7876     }
7877   return i;
7878 }
7879
7880
7881 static int
7882 get_text_align_max_fill_size (int align_pow,
7883                               bfd_boolean use_nops,
7884                               bfd_boolean use_no_density)
7885 {
7886   if (!use_nops)
7887     return (1 << align_pow);
7888   if (use_no_density)
7889     return 3 * (1 << align_pow);
7890
7891   return 1 + (1 << align_pow);
7892 }
7893
7894
7895 /* Calculate the minimum bytes of fill needed at "address" to align a
7896    target instruction of size "target_size" so that it does not cross a
7897    power-of-two boundary specified by "align_pow".  If "use_nops" is FALSE,
7898    the fill can be an arbitrary number of bytes.  Otherwise, the space must
7899    be filled by NOP instructions.  */
7900
7901 static int
7902 get_text_align_fill_size (addressT address,
7903                           int align_pow,
7904                           int target_size,
7905                           bfd_boolean use_nops,
7906                           bfd_boolean use_no_density)
7907 {
7908   addressT alignment, fill, fill_limit, fill_step;
7909   bfd_boolean skip_one = FALSE;
7910
7911   alignment = (1 << align_pow);
7912   assert (target_size > 0 && alignment >= (addressT) target_size);
7913
7914   if (!use_nops)
7915     {
7916       fill_limit = alignment;
7917       fill_step = 1;
7918     }
7919   else if (!use_no_density)
7920     {
7921       /* Combine 2- and 3-byte NOPs to fill anything larger than one.  */
7922       fill_limit = alignment * 2;
7923       fill_step = 1;
7924       skip_one = TRUE;
7925     }
7926   else
7927     {
7928       /* Fill with 3-byte NOPs -- can only fill multiples of 3.  */
7929       fill_limit = alignment * 3;
7930       fill_step = 3;
7931     }
7932
7933   /* Try all fill sizes until finding one that works.  */
7934   for (fill = 0; fill < fill_limit; fill += fill_step)
7935     {
7936       if (skip_one && fill == 1)
7937         continue;
7938       if ((address + fill) >> align_pow
7939           == (address + fill + target_size - 1) >> align_pow)
7940         return fill;
7941     }
7942   assert (0);
7943   return 0;
7944 }
7945
7946
7947 static int
7948 branch_align_power (segT sec)
7949 {
7950   /* If the Xtensa processor has a fetch width of 8 bytes, and the section
7951      is aligned to at least an 8-byte boundary, then a branch target need
7952      only fit within an 8-byte aligned block of memory to avoid a stall.
7953      Otherwise, try to fit branch targets within 4-byte aligned blocks
7954      (which may be insufficient, e.g., if the section has no alignment, but
7955      it's good enough).  */
7956   if (xtensa_fetch_width == 8)
7957     {
7958       if (get_recorded_alignment (sec) >= 3)
7959         return 3;
7960     }
7961   else
7962     assert (xtensa_fetch_width == 4);
7963
7964   return 2;
7965 }
7966
7967
7968 /* This will assert if it is not possible.  */
7969
7970 static int
7971 get_text_align_nop_count (offsetT fill_size, bfd_boolean use_no_density)
7972 {
7973   int count = 0;
7974
7975   if (use_no_density)
7976     {
7977       assert (fill_size % 3 == 0);
7978       return (fill_size / 3);
7979     }
7980
7981   assert (fill_size != 1);      /* Bad argument.  */
7982
7983   while (fill_size > 1)
7984     {
7985       int insn_size = 3;
7986       if (fill_size == 2 || fill_size == 4)
7987         insn_size = 2;
7988       fill_size -= insn_size;
7989       count++;
7990     }
7991   assert (fill_size != 1);      /* Bad algorithm.  */
7992   return count;
7993 }
7994
7995
7996 static int
7997 get_text_align_nth_nop_size (offsetT fill_size,
7998                              int n,
7999                              bfd_boolean use_no_density)
8000 {
8001   int count = 0;
8002
8003   if (use_no_density)
8004     return 3;
8005
8006   assert (fill_size != 1);      /* Bad argument.  */
8007
8008   while (fill_size > 1)
8009     {
8010       int insn_size = 3;
8011       if (fill_size == 2 || fill_size == 4)
8012         insn_size = 2;
8013       fill_size -= insn_size;
8014       count++;
8015       if (n + 1 == count)
8016         return insn_size;
8017     }
8018   assert (0);
8019   return 0;
8020 }
8021
8022
8023 /* For the given fragment, find the appropriate address
8024    for it to begin at if we are using NOPs to align it.  */
8025
8026 static addressT
8027 get_noop_aligned_address (fragS *fragP, addressT address)
8028 {
8029   /* The rule is: get next fragment's FIRST instruction.  Find
8030      the smallest number of bytes that need to be added to
8031      ensure that the next fragment's FIRST instruction will fit
8032      in a single word.
8033
8034      E.G.,   2 bytes : 0, 1, 2 mod 4
8035              3 bytes: 0, 1 mod 4
8036
8037      If the FIRST instruction MIGHT be relaxed,
8038      assume that it will become a 3-byte instruction.
8039
8040      Note again here that LOOP instructions are not bundleable,
8041      and this relaxation only applies to LOOP opcodes.  */
8042
8043   int fill_size = 0;
8044   int first_insn_size;
8045   int loop_insn_size;
8046   addressT pre_opcode_bytes;
8047   int align_power;
8048   fragS *first_insn;
8049   xtensa_opcode opcode;
8050   bfd_boolean is_loop;
8051
8052   assert (fragP->fr_type == rs_machine_dependent);
8053   assert (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE);
8054
8055   /* Find the loop frag.  */
8056   first_insn = next_non_empty_frag (fragP);
8057   /* Now find the first insn frag.  */
8058   first_insn = next_non_empty_frag (first_insn);
8059
8060   is_loop = next_frag_opcode_is_loop (fragP, &opcode);
8061   assert (is_loop);
8062   loop_insn_size = xg_get_single_size (opcode);
8063
8064   pre_opcode_bytes = next_frag_pre_opcode_bytes (fragP);
8065   pre_opcode_bytes += loop_insn_size;
8066
8067   /* For loops, the alignment depends on the size of the
8068      instruction following the loop, not the LOOP instruction.  */
8069
8070   if (first_insn == NULL)
8071     return address;
8072
8073   assert (first_insn->tc_frag_data.is_first_loop_insn);
8074
8075   first_insn_size = frag_format_size (first_insn);
8076
8077   if (first_insn_size == 2 || first_insn_size == XTENSA_UNDEFINED)
8078     first_insn_size = 3;        /* ISA specifies this */
8079
8080   /* If it was 8, then we'll need a larger alignment for the section.  */
8081   align_power = get_text_align_power (first_insn_size);
8082   record_alignment (now_seg, align_power);
8083
8084   fill_size = get_text_align_fill_size
8085     (address + pre_opcode_bytes, align_power, first_insn_size, TRUE,
8086      fragP->tc_frag_data.is_no_density);
8087
8088   return address + fill_size;
8089 }
8090
8091
8092 /* 3 mechanisms for relaxing an alignment:
8093
8094    Align to a power of 2.
8095    Align so the next fragment's instruction does not cross a word boundary.
8096    Align the current instruction so that if the next instruction
8097        were 3 bytes, it would not cross a word boundary.
8098
8099    We can align with:
8100
8101    zeros    - This is easy; always insert zeros.
8102    nops     - 3-byte and 2-byte instructions
8103               2 - 2-byte nop
8104               3 - 3-byte nop
8105               4 - 2 2-byte nops
8106               >=5 : 3-byte instruction + fn (n-3)
8107    widening - widen previous instructions.  */
8108
8109 static offsetT
8110 get_aligned_diff (fragS *fragP, addressT address, offsetT *max_diff)
8111 {
8112   addressT target_address, loop_insn_offset;
8113   int target_size;
8114   xtensa_opcode loop_opcode;
8115   bfd_boolean is_loop;
8116   int align_power;
8117   offsetT opt_diff;
8118   offsetT branch_align;
8119
8120   assert (fragP->fr_type == rs_machine_dependent);
8121   switch (fragP->fr_subtype)
8122     {
8123     case RELAX_DESIRE_ALIGN:
8124       target_size = next_frag_format_size (fragP);
8125       if (target_size == XTENSA_UNDEFINED)
8126         target_size = 3;
8127       align_power = branch_align_power (now_seg);
8128       branch_align = 1 << align_power;
8129       /* Don't count on the section alignment being as large as the target.  */
8130       if (target_size > branch_align)
8131         target_size = branch_align;
8132       opt_diff = get_text_align_fill_size (address, align_power,
8133                                            target_size, FALSE, FALSE);
8134
8135       *max_diff = (opt_diff + branch_align
8136                    - (target_size + ((address + opt_diff) % branch_align)));
8137       assert (*max_diff >= opt_diff);
8138       return opt_diff;
8139
8140     case RELAX_ALIGN_NEXT_OPCODE:
8141       target_size = next_frag_format_size (fragP);
8142       loop_insn_offset = 0;
8143       is_loop = next_frag_opcode_is_loop (fragP, &loop_opcode);
8144       assert (is_loop);
8145
8146       /* If the loop has been expanded then the LOOP instruction
8147          could be at an offset from this fragment.  */
8148       if (next_non_empty_frag(fragP)->tc_frag_data.slot_subtypes[0]
8149           != RELAX_IMMED)
8150         loop_insn_offset = get_expanded_loop_offset (loop_opcode);
8151
8152       if (target_size == 2)
8153         target_size = 3; /* ISA specifies this */
8154
8155       /* In an ideal world, which is what we are shooting for here,
8156          we wouldn't need to use any NOPs immediately prior to the
8157          LOOP instruction.  If this approach fails, relax_frag_loop_align
8158          will call get_noop_aligned_address.  */
8159       target_address =
8160         address + loop_insn_offset + xg_get_single_size (loop_opcode);
8161       align_power = get_text_align_power (target_size),
8162       opt_diff = get_text_align_fill_size (target_address, align_power,
8163                                            target_size, FALSE, FALSE);
8164
8165       *max_diff = xtensa_fetch_width
8166         - ((target_address + opt_diff) % xtensa_fetch_width)
8167         - target_size + opt_diff;
8168       assert (*max_diff >= opt_diff);
8169       return opt_diff;
8170
8171     default:
8172       break;
8173     }
8174   assert (0);
8175   return 0;
8176 }
8177
8178 \f
8179 /* md_relax_frag Hook and Helper Functions.  */
8180
8181 static long relax_frag_loop_align (fragS *, long);
8182 static long relax_frag_for_align (fragS *, long);
8183 static long relax_frag_immed
8184   (segT, fragS *, long, int, xtensa_format, int, int *, bfd_boolean);
8185
8186
8187 /* Return the number of bytes added to this fragment, given that the
8188    input has been stretched already by "stretch".  */
8189
8190 long
8191 xtensa_relax_frag (fragS *fragP, long stretch, int *stretched_p)
8192 {
8193   xtensa_isa isa = xtensa_default_isa;
8194   int unreported = fragP->tc_frag_data.unreported_expansion;
8195   long new_stretch = 0;
8196   char *file_name;
8197   unsigned line;
8198   int lit_size;
8199   static xtensa_insnbuf vbuf = NULL;
8200   int slot, num_slots;
8201   xtensa_format fmt;
8202
8203   as_where (&file_name, &line);
8204   new_logical_line (fragP->fr_file, fragP->fr_line);
8205
8206   fragP->tc_frag_data.unreported_expansion = 0;
8207
8208   switch (fragP->fr_subtype)
8209     {
8210     case RELAX_ALIGN_NEXT_OPCODE:
8211       /* Always convert.  */
8212       if (fragP->tc_frag_data.relax_seen)
8213         new_stretch = relax_frag_loop_align (fragP, stretch);
8214       break;
8215
8216     case RELAX_LOOP_END:
8217       /* Do nothing.  */
8218       break;
8219
8220     case RELAX_LOOP_END_ADD_NOP:
8221       /* Add a NOP and switch to .fill 0.  */
8222       new_stretch = relax_frag_add_nop (fragP);
8223       frag_wane (fragP);
8224       break;
8225
8226     case RELAX_DESIRE_ALIGN:
8227       /* Do nothing. The narrowing before this frag will either align
8228          it or not.  */
8229       break;
8230
8231     case RELAX_LITERAL:
8232     case RELAX_LITERAL_FINAL:
8233       return 0;
8234
8235     case RELAX_LITERAL_NR:
8236       lit_size = 4;
8237       fragP->fr_subtype = RELAX_LITERAL_FINAL;
8238       assert (unreported == lit_size);
8239       memset (&fragP->fr_literal[fragP->fr_fix], 0, 4);
8240       fragP->fr_var -= lit_size;
8241       fragP->fr_fix += lit_size;
8242       new_stretch = 4;
8243       break;
8244
8245     case RELAX_SLOTS:
8246       if (vbuf == NULL)
8247         vbuf = xtensa_insnbuf_alloc (isa);
8248
8249       xtensa_insnbuf_from_chars
8250         (isa, vbuf, (unsigned char *) fragP->fr_opcode, 0);
8251       fmt = xtensa_format_decode (isa, vbuf);
8252       num_slots = xtensa_format_num_slots (isa, fmt);
8253
8254       for (slot = 0; slot < num_slots; slot++)
8255         {
8256           switch (fragP->tc_frag_data.slot_subtypes[slot])
8257             {
8258             case RELAX_NARROW:
8259               if (fragP->tc_frag_data.relax_seen)
8260                 new_stretch += relax_frag_for_align (fragP, stretch);
8261               break;
8262
8263             case RELAX_IMMED:
8264             case RELAX_IMMED_STEP1:
8265             case RELAX_IMMED_STEP2:
8266               /* Place the immediate.  */
8267               new_stretch += relax_frag_immed
8268                 (now_seg, fragP, stretch,
8269                  fragP->tc_frag_data.slot_subtypes[slot] - RELAX_IMMED,
8270                  fmt, slot, stretched_p, FALSE);
8271               break;
8272
8273             default:
8274               /* This is OK; see the note in xg_assemble_vliw_tokens.  */
8275               break;
8276             }
8277         }
8278       break;
8279
8280     case RELAX_LITERAL_POOL_BEGIN:
8281     case RELAX_LITERAL_POOL_END:
8282     case RELAX_MAYBE_UNREACHABLE:
8283     case RELAX_MAYBE_DESIRE_ALIGN:
8284       /* No relaxation required.  */
8285       break;
8286
8287     case RELAX_FILL_NOP:
8288     case RELAX_UNREACHABLE:
8289       if (fragP->tc_frag_data.relax_seen)
8290         new_stretch += relax_frag_for_align (fragP, stretch);
8291       break;
8292
8293     default:
8294       as_bad (_("bad relaxation state"));
8295     }
8296
8297   /* Tell gas we need another relaxation pass.  */
8298   if (! fragP->tc_frag_data.relax_seen)
8299     {
8300       fragP->tc_frag_data.relax_seen = TRUE;
8301       *stretched_p = 1;
8302     }
8303
8304   new_logical_line (file_name, line);
8305   return new_stretch;
8306 }
8307
8308
8309 static long
8310 relax_frag_loop_align (fragS *fragP, long stretch)
8311 {
8312   addressT old_address, old_next_address, old_size;
8313   addressT new_address, new_next_address, new_size;
8314   addressT growth;
8315
8316   /* All the frags with relax_frag_for_alignment prior to this one in the
8317      section have been done, hopefully eliminating the need for a NOP here.
8318      But, this will put it in if necessary.  */
8319
8320   /* Calculate the old address of this fragment and the next fragment.  */
8321   old_address = fragP->fr_address - stretch;
8322   old_next_address = (fragP->fr_address - stretch + fragP->fr_fix +
8323                       fragP->tc_frag_data.text_expansion[0]);
8324   old_size = old_next_address - old_address;
8325
8326   /* Calculate the new address of this fragment and the next fragment.  */
8327   new_address = fragP->fr_address;
8328   new_next_address =
8329     get_noop_aligned_address (fragP, fragP->fr_address + fragP->fr_fix);
8330   new_size = new_next_address - new_address;
8331
8332   growth = new_size - old_size;
8333
8334   /* Fix up the text_expansion field and return the new growth.  */
8335   fragP->tc_frag_data.text_expansion[0] += growth;
8336   return growth;
8337 }
8338
8339
8340 /* Add a NOP instruction.  */
8341
8342 static long
8343 relax_frag_add_nop (fragS *fragP)
8344 {
8345   char *nop_buf = fragP->fr_literal + fragP->fr_fix;
8346   int length = fragP->tc_frag_data.is_no_density ? 3 : 2;
8347   assemble_nop (length, nop_buf);
8348   fragP->tc_frag_data.is_insn = TRUE;
8349
8350   if (fragP->fr_var < length)
8351     {
8352       as_fatal (_("fr_var (%ld) < length (%d)"), (long) fragP->fr_var, length);
8353       return 0;
8354     }
8355
8356   fragP->fr_fix += length;
8357   fragP->fr_var -= length;
8358   return length;
8359 }
8360
8361
8362 static long future_alignment_required (fragS *, long);
8363
8364 static long
8365 relax_frag_for_align (fragS *fragP, long stretch)
8366 {
8367   /* Overview of the relaxation procedure for alignment:
8368      We can widen with NOPs or by widening instructions or by filling
8369      bytes after jump instructions.  Find the opportune places and widen
8370      them if necessary.  */
8371
8372   long stretch_me;
8373   long diff;
8374
8375   assert (fragP->fr_subtype == RELAX_FILL_NOP
8376           || fragP->fr_subtype == RELAX_UNREACHABLE
8377           || (fragP->fr_subtype == RELAX_SLOTS
8378               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW));
8379
8380   stretch_me = future_alignment_required (fragP, stretch);
8381   diff = stretch_me - fragP->tc_frag_data.text_expansion[0];
8382   if (diff == 0)
8383     return 0;
8384
8385   if (diff < 0)
8386     {
8387       /* We expanded on a previous pass.  Can we shrink now?  */
8388       long shrink = fragP->tc_frag_data.text_expansion[0] - stretch_me;
8389       if (shrink <= stretch && stretch > 0)
8390         {
8391           fragP->tc_frag_data.text_expansion[0] = stretch_me;
8392           return -shrink;
8393         }
8394       return 0;
8395     }
8396
8397   /* Below here, diff > 0.  */
8398   fragP->tc_frag_data.text_expansion[0] = stretch_me;
8399
8400   return diff;
8401 }
8402
8403
8404 /* Return the address of the next frag that should be aligned.
8405
8406    By "address" we mean the address it _would_ be at if there
8407    is no action taken to align it between here and the target frag.
8408    In other words, if no narrows and no fill nops are used between
8409    here and the frag to align, _even_if_ some of the frags we use
8410    to align targets have already expanded on a previous relaxation
8411    pass.
8412
8413    Also, count each frag that may be used to help align the target.
8414
8415    Return 0 if there are no frags left in the chain that need to be
8416    aligned.  */
8417
8418 static addressT
8419 find_address_of_next_align_frag (fragS **fragPP,
8420                                  int *wide_nops,
8421                                  int *narrow_nops,
8422                                  int *widens,
8423                                  bfd_boolean *paddable)
8424 {
8425   fragS *fragP = *fragPP;
8426   addressT address = fragP->fr_address;
8427
8428   /* Do not reset the counts to 0.  */
8429
8430   while (fragP)
8431     {
8432       /* Limit this to a small search.  */
8433       if (*widens > 8)
8434         {
8435           *fragPP = fragP;
8436           return 0;
8437         }
8438       address += fragP->fr_fix;
8439
8440       if (fragP->fr_type == rs_fill)
8441         address += fragP->fr_offset * fragP->fr_var;
8442       else if (fragP->fr_type == rs_machine_dependent)
8443         {
8444           switch (fragP->fr_subtype)
8445             {
8446             case RELAX_UNREACHABLE:
8447               *paddable = TRUE;
8448               break;
8449
8450             case RELAX_FILL_NOP:
8451               (*wide_nops)++;
8452               if (!fragP->tc_frag_data.is_no_density)
8453                 (*narrow_nops)++;
8454               break;
8455
8456             case RELAX_SLOTS:
8457               if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
8458                 {
8459                   (*widens)++;
8460                   break;
8461                 }
8462               address += total_frag_text_expansion (fragP);;
8463               break;
8464
8465             case RELAX_IMMED:
8466               address += fragP->tc_frag_data.text_expansion[0];
8467               break;
8468
8469             case RELAX_ALIGN_NEXT_OPCODE:
8470             case RELAX_DESIRE_ALIGN:
8471               *fragPP = fragP;
8472               return address;
8473
8474             case RELAX_MAYBE_UNREACHABLE:
8475             case RELAX_MAYBE_DESIRE_ALIGN:
8476               /* Do nothing.  */
8477               break;
8478
8479             default:
8480               /* Just punt if we don't know the type.  */
8481               *fragPP = fragP;
8482               return 0;
8483             }
8484         }
8485       else
8486         {
8487           /* Just punt if we don't know the type.  */
8488           *fragPP = fragP;
8489           return 0;
8490         }
8491       fragP = fragP->fr_next;
8492     }
8493
8494   *fragPP = fragP;
8495   return 0;
8496 }
8497
8498
8499 static long bytes_to_stretch (fragS *, int, int, int, int);
8500
8501 static long
8502 future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
8503 {
8504   fragS *this_frag = fragP;
8505   long address;
8506   int num_widens = 0;
8507   int wide_nops = 0;
8508   int narrow_nops = 0;
8509   bfd_boolean paddable = FALSE;
8510   offsetT local_opt_diff;
8511   offsetT opt_diff;
8512   offsetT max_diff;
8513   int stretch_amount = 0;
8514   int local_stretch_amount;
8515   int global_stretch_amount;
8516
8517   address = find_address_of_next_align_frag
8518     (&fragP, &wide_nops, &narrow_nops, &num_widens, &paddable);
8519
8520   if (address)
8521     {
8522       local_opt_diff = get_aligned_diff (fragP, address, &max_diff);
8523       opt_diff = local_opt_diff;
8524       assert (opt_diff >= 0);
8525       assert (max_diff >= opt_diff);
8526       if (max_diff == 0)
8527         return 0;
8528
8529       if (fragP)
8530         fragP = fragP->fr_next;
8531
8532       while (fragP && opt_diff < max_diff && address)
8533         {
8534           /* We only use these to determine if we can exit early
8535              because there will be plenty of ways to align future
8536              align frags.  */
8537           int glob_widens = 0;
8538           int dnn = 0;
8539           int dw = 0;
8540           bfd_boolean glob_pad = 0;
8541           address = find_address_of_next_align_frag
8542             (&fragP, &glob_widens, &dnn, &dw, &glob_pad);
8543           /* If there is a padable portion, then skip.  */
8544           if (glob_pad || glob_widens >= (1 << branch_align_power (now_seg)))
8545             break;
8546
8547           if (address)
8548             {
8549               offsetT next_m_diff;
8550               offsetT next_o_diff;
8551
8552               /* Downrange frags haven't had stretch added to them yet.  */
8553               address += stretch;
8554
8555               /* The address also includes any text expansion from this
8556                  frag in a previous pass, but we don't want that.  */
8557               address -= this_frag->tc_frag_data.text_expansion[0];
8558
8559               /* Assume we are going to move at least opt_diff.  In
8560                  reality, we might not be able to, but assuming that
8561                  we will helps catch cases where moving opt_diff pushes
8562                  the next target from aligned to unaligned.  */
8563               address += opt_diff;
8564
8565               next_o_diff = get_aligned_diff (fragP, address, &next_m_diff);
8566
8567               /* Now cleanup for the adjustments to address.  */
8568               next_o_diff += opt_diff;
8569               next_m_diff += opt_diff;
8570               if (next_o_diff <= max_diff && next_o_diff > opt_diff)
8571                 opt_diff = next_o_diff;
8572               if (next_m_diff < max_diff)
8573                 max_diff = next_m_diff;
8574               fragP = fragP->fr_next;
8575             }
8576         }
8577
8578       /* If there are enough wideners in between, do it.  */
8579       if (paddable)
8580         {
8581           if (this_frag->fr_subtype == RELAX_UNREACHABLE)
8582             {
8583               assert (opt_diff <= UNREACHABLE_MAX_WIDTH);
8584               return opt_diff;
8585             }
8586           return 0;
8587         }
8588       local_stretch_amount
8589         = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
8590                             num_widens, local_opt_diff);
8591       global_stretch_amount
8592         = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
8593                             num_widens, opt_diff);
8594       /* If the condition below is true, then the frag couldn't
8595          stretch the correct amount for the global case, so we just
8596          optimize locally.  We'll rely on the subsequent frags to get
8597          the correct alignment in the global case.  */
8598       if (global_stretch_amount < local_stretch_amount)
8599         stretch_amount = local_stretch_amount;
8600       else
8601         stretch_amount = global_stretch_amount;
8602
8603       if (this_frag->fr_subtype == RELAX_SLOTS
8604           && this_frag->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
8605         assert (stretch_amount <= 1);
8606       else if (this_frag->fr_subtype == RELAX_FILL_NOP)
8607         {
8608           if (this_frag->tc_frag_data.is_no_density)
8609             assert (stretch_amount == 3 || stretch_amount == 0);
8610           else
8611             assert (stretch_amount <= 3);
8612         }
8613     }
8614   return stretch_amount;
8615 }
8616
8617
8618 /* The idea: widen everything you can to get a target or loop aligned,
8619    then start using NOPs.
8620
8621    When we must have a NOP, here is a table of how we decide
8622    (so you don't have to fight through the control flow below):
8623
8624    wide_nops   = the number of wide NOPs available for aligning
8625    narrow_nops = the number of narrow NOPs available for aligning
8626                  (a subset of wide_nops)
8627    widens      = the number of narrow instructions that should be widened
8628
8629    Desired   wide   narrow
8630    Diff      nop    nop      widens
8631    1           0      0         1
8632    2           0      1         0
8633    3a          1      0         0
8634     b          0      1         1 (case 3a makes this case unnecessary)
8635    4a          1      0         1
8636     b          0      2         0
8637     c          0      1         2 (case 4a makes this case unnecessary)
8638    5a          1      0         2
8639     b          1      1         0
8640     c          0      2         1 (case 5b makes this case unnecessary)
8641    6a          2      0         0
8642     b          1      0         3
8643     c          0      1         4 (case 6b makes this case unneccesary)
8644     d          1      1         1 (case 6a makes this case unnecessary)
8645     e          0      2         2 (case 6a makes this case unnecessary)
8646     f          0      3         0 (case 6a makes this case unnecessary)
8647    7a          1      0         4
8648     b          2      0         1
8649     c          1      1         2 (case 7b makes this case unnecessary)
8650     d          0      1         5 (case 7a makes this case unnecessary)
8651     e          0      2         3 (case 7b makes this case unnecessary)
8652     f          0      3         1 (case 7b makes this case unnecessary)
8653     g          1      2         1 (case 7b makes this case unnecessary)
8654 */
8655
8656 static long
8657 bytes_to_stretch (fragS *this_frag,
8658                   int wide_nops,
8659                   int narrow_nops,
8660                   int num_widens,
8661                   int desired_diff)
8662 {
8663   int bytes_short = desired_diff - num_widens;
8664
8665   assert (desired_diff >= 0 && desired_diff < 8);
8666   if (desired_diff == 0)
8667     return 0;
8668
8669   assert (wide_nops > 0 || num_widens > 0);
8670
8671   /* Always prefer widening to NOP-filling.  */
8672   if (bytes_short < 0)
8673     {
8674       /* There are enough RELAX_NARROW frags after this one
8675          to align the target without widening this frag in any way.  */
8676       return 0;
8677     }
8678
8679   if (bytes_short == 0)
8680     {
8681       /* Widen every narrow between here and the align target
8682          and the align target will be properly aligned.  */
8683       if (this_frag->fr_subtype == RELAX_FILL_NOP)
8684         return 0;
8685       else
8686         return 1;
8687     }
8688
8689   /* From here we will need at least one NOP to get an alignment.
8690      However, we may not be able to align at all, in which case,
8691      don't widen.  */
8692   if (this_frag->fr_subtype == RELAX_FILL_NOP)
8693     {
8694       switch (desired_diff)
8695         {
8696         case 1:
8697           return 0;
8698         case 2:
8699           if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 1)
8700             return 2; /* case 2 */
8701           return 0;
8702         case 3:
8703           if (wide_nops > 1)
8704             return 0;
8705           else
8706             return 3; /* case 3a */
8707         case 4:
8708           if (num_widens >= 1 && wide_nops == 1)
8709             return 3; /* case 4a */
8710           if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 2)
8711             return 2; /* case 4b */
8712           return 0;
8713         case 5:
8714           if (num_widens >= 2 && wide_nops == 1)
8715             return 3; /* case 5a */
8716           /* We will need two nops.  Are there enough nops
8717              between here and the align target?  */
8718           if (wide_nops < 2 || narrow_nops == 0)
8719             return 0;
8720           /* Are there other nops closer that can serve instead?  */
8721           if (wide_nops > 2 && narrow_nops > 1)
8722             return 0;
8723           /* Take the density one first, because there might not be
8724              another density one available.  */
8725           if (!this_frag->tc_frag_data.is_no_density)
8726             return 2; /* case 5b narrow */
8727           else
8728             return 3; /* case 5b wide */
8729           return 0;
8730         case 6:
8731           if (wide_nops == 2)
8732             return 3; /* case 6a */
8733           else if (num_widens >= 3 && wide_nops == 1)
8734             return 3; /* case 6b */
8735           return 0;
8736         case 7:
8737           if (wide_nops == 1 && num_widens >= 4)
8738             return 3; /* case 7a */
8739           else if (wide_nops == 2 && num_widens >= 1)
8740             return 3; /* case 7b */
8741           return 0;
8742         default:
8743           assert (0);
8744         }
8745     }
8746   else
8747     {
8748       /* We will need a NOP no matter what, but should we widen
8749          this instruction to help?
8750
8751          This is a RELAX_FRAG_NARROW frag.  */
8752       switch (desired_diff)
8753         {
8754         case 1:
8755           assert (0);
8756           return 0;
8757         case 2:
8758         case 3:
8759           return 0;
8760         case 4:
8761           if (wide_nops >= 1 && num_widens == 1)
8762             return 1; /* case 4a */
8763           return 0;
8764         case 5:
8765           if (wide_nops >= 1 && num_widens == 2)
8766             return 1; /* case 5a */
8767           return 0;
8768         case 6:
8769           if (wide_nops >= 2)
8770             return 0; /* case 6a */
8771           else if (wide_nops >= 1 && num_widens == 3)
8772             return 1; /* case 6b */
8773           return 0;
8774         case 7:
8775           if (wide_nops >= 1 && num_widens == 4)
8776             return 1; /* case 7a */
8777           else if (wide_nops >= 2 && num_widens == 1)
8778             return 1; /* case 7b */
8779           return 0;
8780         default:
8781           assert (0);
8782           return 0;
8783         }
8784     }
8785   assert (0);
8786   return 0;
8787 }
8788
8789
8790 static long
8791 relax_frag_immed (segT segP,
8792                   fragS *fragP,
8793                   long stretch,
8794                   int min_steps,
8795                   xtensa_format fmt,
8796                   int slot,
8797                   int *stretched_p,
8798                   bfd_boolean estimate_only)
8799 {
8800   TInsn tinsn;
8801   vliw_insn orig_vinsn;
8802   int old_size;
8803   bfd_boolean negatable_branch = FALSE;
8804   bfd_boolean branch_jmp_to_next = FALSE;
8805   bfd_boolean wide_insn = FALSE;
8806   xtensa_isa isa = xtensa_default_isa;
8807   IStack istack;
8808   offsetT frag_offset;
8809   int num_steps;
8810   fragS *lit_fragP;
8811   int num_text_bytes, num_literal_bytes;
8812   int literal_diff, total_text_diff, this_text_diff, first;
8813
8814   assert (fragP->fr_opcode != NULL);
8815
8816   xg_init_vinsn (&orig_vinsn);
8817   vinsn_from_chars (&orig_vinsn, fragP->fr_opcode);
8818   if (xtensa_format_num_slots (isa, fmt) > 1)
8819     wide_insn = TRUE;
8820
8821   tinsn = orig_vinsn.slots[slot];
8822   tinsn_immed_from_frag (&tinsn, fragP, slot);
8823
8824   if (estimate_only && xtensa_opcode_is_loop (isa, tinsn.opcode))
8825     return 0;
8826
8827   if (workaround_b_j_loop_end && ! fragP->tc_frag_data.is_no_transform)
8828     branch_jmp_to_next = is_branch_jmp_to_next (&tinsn, fragP);
8829
8830   negatable_branch = (xtensa_opcode_is_branch (isa, tinsn.opcode) == 1);
8831
8832   old_size = xtensa_format_length (isa, fmt);
8833
8834   /* Special case: replace a branch to the next instruction with a NOP.
8835      This is required to work around a hardware bug in T1040.0 and also
8836      serves as an optimization.  */
8837
8838   if (branch_jmp_to_next
8839       && ((old_size == 2) || (old_size == 3))
8840       && !next_frag_is_loop_target (fragP))
8841     return 0;
8842
8843   /* Here is the fun stuff: Get the immediate field from this
8844      instruction.  If it fits, we are done.  If not, find the next
8845      instruction sequence that fits.  */
8846
8847   frag_offset = fragP->fr_opcode - fragP->fr_literal;
8848   istack_init (&istack);
8849   num_steps = xg_assembly_relax (&istack, &tinsn, segP, fragP, frag_offset,
8850                                  min_steps, stretch);
8851   if (num_steps < min_steps)
8852     {
8853       as_fatal (_("internal error: relaxation failed"));
8854       return 0;
8855     }
8856
8857   if (num_steps > RELAX_IMMED_MAXSTEPS)
8858     {
8859       as_fatal (_("internal error: relaxation requires too many steps"));
8860       return 0;
8861     }
8862
8863   fragP->tc_frag_data.slot_subtypes[slot] = (int) RELAX_IMMED + num_steps;
8864
8865   /* Figure out the number of bytes needed.  */
8866   lit_fragP = 0;
8867   num_literal_bytes = get_num_stack_literal_bytes (&istack);
8868   literal_diff =
8869     num_literal_bytes - fragP->tc_frag_data.literal_expansion[slot];
8870   first = 0;
8871   while (istack.insn[first].opcode == XTENSA_UNDEFINED)
8872     first++;
8873   num_text_bytes = get_num_stack_text_bytes (&istack);
8874   if (wide_insn)
8875     {
8876       num_text_bytes += old_size;
8877       if (opcode_fits_format_slot (istack.insn[first].opcode, fmt, slot))
8878         num_text_bytes -= xg_get_single_size (istack.insn[first].opcode);
8879     }
8880   total_text_diff = num_text_bytes - old_size;
8881   this_text_diff = total_text_diff - fragP->tc_frag_data.text_expansion[slot];
8882
8883   /* It MUST get larger.  If not, we could get an infinite loop.  */
8884   assert (num_text_bytes >= 0);
8885   assert (literal_diff >= 0);
8886   assert (total_text_diff >= 0);
8887
8888   fragP->tc_frag_data.text_expansion[slot] = total_text_diff;
8889   fragP->tc_frag_data.literal_expansion[slot] = num_literal_bytes;
8890   assert (fragP->tc_frag_data.text_expansion[slot] >= 0);
8891   assert (fragP->tc_frag_data.literal_expansion[slot] >= 0);
8892
8893   /* Find the associated expandable literal for this.  */
8894   if (literal_diff != 0)
8895     {
8896       lit_fragP = fragP->tc_frag_data.literal_frags[slot];
8897       if (lit_fragP)
8898         {
8899           assert (literal_diff == 4);
8900           lit_fragP->tc_frag_data.unreported_expansion += literal_diff;
8901
8902           /* We expect that the literal section state has NOT been
8903              modified yet.  */
8904           assert (lit_fragP->fr_type == rs_machine_dependent
8905                   && lit_fragP->fr_subtype == RELAX_LITERAL);
8906           lit_fragP->fr_subtype = RELAX_LITERAL_NR;
8907
8908           /* We need to mark this section for another iteration
8909              of relaxation.  */
8910           (*stretched_p)++;
8911         }
8912     }
8913
8914   if (negatable_branch && istack.ninsn > 1)
8915     update_next_frag_state (fragP);
8916
8917   return this_text_diff;
8918 }
8919
8920 \f
8921 /* md_convert_frag Hook and Helper Functions.  */
8922
8923 static void convert_frag_align_next_opcode (fragS *);
8924 static void convert_frag_narrow (segT, fragS *, xtensa_format, int);
8925 static void convert_frag_fill_nop (fragS *);
8926 static void convert_frag_immed (segT, fragS *, int, xtensa_format, int);
8927
8928 void
8929 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec, fragS *fragp)
8930 {
8931   static xtensa_insnbuf vbuf = NULL;
8932   xtensa_isa isa = xtensa_default_isa;
8933   int slot;
8934   int num_slots;
8935   xtensa_format fmt;
8936   char *file_name;
8937   unsigned line;
8938
8939   as_where (&file_name, &line);
8940   new_logical_line (fragp->fr_file, fragp->fr_line);
8941
8942   switch (fragp->fr_subtype)
8943     {
8944     case RELAX_ALIGN_NEXT_OPCODE:
8945       /* Always convert.  */
8946       convert_frag_align_next_opcode (fragp);
8947       break;
8948
8949     case RELAX_DESIRE_ALIGN:
8950       /* Do nothing.  If not aligned already, too bad.  */
8951       break;
8952
8953     case RELAX_LITERAL:
8954     case RELAX_LITERAL_FINAL:
8955       break;
8956
8957     case RELAX_SLOTS:
8958       if (vbuf == NULL)
8959         vbuf = xtensa_insnbuf_alloc (isa);
8960
8961       xtensa_insnbuf_from_chars
8962         (isa, vbuf, (unsigned char *) fragp->fr_opcode, 0);
8963       fmt = xtensa_format_decode (isa, vbuf);
8964       num_slots = xtensa_format_num_slots (isa, fmt);
8965
8966       for (slot = 0; slot < num_slots; slot++)
8967         {
8968           switch (fragp->tc_frag_data.slot_subtypes[slot])
8969             {
8970             case RELAX_NARROW:
8971               convert_frag_narrow (sec, fragp, fmt, slot);
8972               break;
8973
8974             case RELAX_IMMED:
8975             case RELAX_IMMED_STEP1:
8976             case RELAX_IMMED_STEP2:
8977               /* Place the immediate.  */
8978               convert_frag_immed
8979                 (sec, fragp,
8980                  fragp->tc_frag_data.slot_subtypes[slot] - RELAX_IMMED,
8981                  fmt, slot);
8982               break;
8983
8984             default:
8985               /* This is OK because some slots could have
8986                  relaxations and others have none.  */
8987               break;
8988             }
8989         }
8990       break;
8991
8992     case RELAX_UNREACHABLE:
8993       memset (&fragp->fr_literal[fragp->fr_fix], 0, fragp->fr_var);
8994       fragp->fr_fix += fragp->tc_frag_data.text_expansion[0];
8995       fragp->fr_var -= fragp->tc_frag_data.text_expansion[0];
8996       frag_wane (fragp);
8997       break;
8998
8999     case RELAX_MAYBE_UNREACHABLE:
9000     case RELAX_MAYBE_DESIRE_ALIGN:
9001       frag_wane (fragp);
9002       break;
9003
9004     case RELAX_FILL_NOP:
9005       convert_frag_fill_nop (fragp);
9006       break;
9007
9008     case RELAX_LITERAL_NR:
9009       if (use_literal_section)
9010         {
9011           /* This should have been handled during relaxation.  When
9012              relaxing a code segment, literals sometimes need to be
9013              added to the corresponding literal segment.  If that
9014              literal segment has already been relaxed, then we end up
9015              in this situation.  Marking the literal segments as data
9016              would make this happen less often (since GAS always relaxes
9017              code before data), but we could still get into trouble if
9018              there are instructions in a segment that is not marked as
9019              containing code.  Until we can implement a better solution,
9020              cheat and adjust the addresses of all the following frags.
9021              This could break subsequent alignments, but the linker's
9022              literal coalescing will do that anyway.  */
9023
9024           fragS *f;
9025           fragp->fr_subtype = RELAX_LITERAL_FINAL;
9026           assert (fragp->tc_frag_data.unreported_expansion == 4);
9027           memset (&fragp->fr_literal[fragp->fr_fix], 0, 4);
9028           fragp->fr_var -= 4;
9029           fragp->fr_fix += 4;
9030           for (f = fragp->fr_next; f; f = f->fr_next)
9031             f->fr_address += 4;
9032         }
9033       else
9034         as_bad (_("invalid relaxation fragment result"));
9035       break;
9036     }
9037
9038   fragp->fr_var = 0;
9039   new_logical_line (file_name, line);
9040 }
9041
9042
9043 static void
9044 convert_frag_align_next_opcode (fragS *fragp)
9045 {
9046   char *nop_buf;                /* Location for Writing.  */
9047   bfd_boolean use_no_density = fragp->tc_frag_data.is_no_density;
9048   addressT aligned_address;
9049   offsetT fill_size;
9050   int nop, nop_count;
9051
9052   aligned_address = get_noop_aligned_address (fragp, fragp->fr_address +
9053                                               fragp->fr_fix);
9054   fill_size = aligned_address - (fragp->fr_address + fragp->fr_fix);
9055   nop_count = get_text_align_nop_count (fill_size, use_no_density);
9056   nop_buf = fragp->fr_literal + fragp->fr_fix;
9057
9058   for (nop = 0; nop < nop_count; nop++)
9059     {
9060       int nop_size;
9061       nop_size = get_text_align_nth_nop_size (fill_size, nop, use_no_density);
9062
9063       assemble_nop (nop_size, nop_buf);
9064       nop_buf += nop_size;
9065     }
9066
9067   fragp->fr_fix += fill_size;
9068   fragp->fr_var -= fill_size;
9069 }
9070
9071
9072 static void
9073 convert_frag_narrow (segT segP, fragS *fragP, xtensa_format fmt, int slot)
9074 {
9075   TInsn tinsn, single_target;
9076   xtensa_format single_fmt;
9077   int size, old_size, diff;
9078   offsetT frag_offset;
9079
9080   assert (slot == 0);
9081   tinsn_from_chars (&tinsn, fragP->fr_opcode, 0);
9082
9083   if (xtensa_opcode_is_branch (xtensa_default_isa, tinsn.opcode) == 1)
9084     {
9085       assert (fragP->tc_frag_data.text_expansion[0] == 1
9086               || fragP->tc_frag_data.text_expansion[0] == 0);
9087       convert_frag_immed (segP, fragP, fragP->tc_frag_data.text_expansion[0],
9088                           fmt, slot);
9089       return;
9090     }
9091
9092   if (fragP->tc_frag_data.text_expansion[0] == 0)
9093     {
9094       /* No conversion.  */
9095       fragP->fr_var = 0;
9096       return;
9097     }
9098
9099   assert (fragP->fr_opcode != NULL);
9100
9101   /* Frags in this relaxation state should only contain
9102      single instruction bundles.  */
9103   tinsn_immed_from_frag (&tinsn, fragP, 0);
9104
9105   /* Just convert it to a wide form....  */
9106   size = 0;
9107   old_size = xg_get_single_size (tinsn.opcode);
9108
9109   tinsn_init (&single_target);
9110   frag_offset = fragP->fr_opcode - fragP->fr_literal;
9111
9112   if (! xg_is_single_relaxable_insn (&tinsn, &single_target, FALSE))
9113     {
9114       as_bad (_("unable to widen instruction"));
9115       return;
9116     }
9117
9118   size = xg_get_single_size (single_target.opcode);
9119   single_fmt = xg_get_single_format (single_target.opcode);
9120
9121   xg_emit_insn_to_buf (&single_target, single_fmt, fragP->fr_opcode,
9122                        fragP, frag_offset, TRUE);
9123
9124   diff = size - old_size;
9125   assert (diff >= 0);
9126   assert (diff <= fragP->fr_var);
9127   fragP->fr_var -= diff;
9128   fragP->fr_fix += diff;
9129
9130   /* clean it up */
9131   fragP->fr_var = 0;
9132 }
9133
9134
9135 static void
9136 convert_frag_fill_nop (fragS *fragP)
9137 {
9138   char *loc = &fragP->fr_literal[fragP->fr_fix];
9139   int size = fragP->tc_frag_data.text_expansion[0];
9140   assert ((unsigned) size == (fragP->fr_next->fr_address
9141                               - fragP->fr_address - fragP->fr_fix));
9142   if (size == 0)
9143     {
9144       /* No conversion.  */
9145       fragP->fr_var = 0;
9146       return;
9147     }
9148   assemble_nop (size, loc);
9149   fragP->tc_frag_data.is_insn = TRUE;
9150   fragP->fr_var -= size;
9151   fragP->fr_fix += size;
9152   frag_wane (fragP);
9153 }
9154
9155
9156 static fixS *fix_new_exp_in_seg
9157   (segT, subsegT, fragS *, int, int, expressionS *, int,
9158    bfd_reloc_code_real_type);
9159 static void convert_frag_immed_finish_loop (segT, fragS *, TInsn *);
9160
9161 static void
9162 convert_frag_immed (segT segP,
9163                     fragS *fragP,
9164                     int min_steps,
9165                     xtensa_format fmt,
9166                     int slot)
9167 {
9168   char *immed_instr = fragP->fr_opcode;
9169   TInsn orig_tinsn;
9170   bfd_boolean expanded = FALSE;
9171   bfd_boolean branch_jmp_to_next = FALSE;
9172   char *fr_opcode = fragP->fr_opcode;
9173   vliw_insn orig_vinsn;
9174   xtensa_isa isa = xtensa_default_isa;
9175   bfd_boolean wide_insn = FALSE;
9176   int bytes;
9177   bfd_boolean is_loop;
9178
9179   assert (fr_opcode != NULL);
9180
9181   xg_init_vinsn (&orig_vinsn);
9182
9183   vinsn_from_chars (&orig_vinsn, fr_opcode);
9184   if (xtensa_format_num_slots (isa, fmt) > 1)
9185     wide_insn = TRUE;
9186
9187   orig_tinsn = orig_vinsn.slots[slot];
9188   tinsn_immed_from_frag (&orig_tinsn, fragP, slot);
9189
9190   is_loop = xtensa_opcode_is_loop (xtensa_default_isa, orig_tinsn.opcode) == 1;
9191
9192   if (workaround_b_j_loop_end && ! fragP->tc_frag_data.is_no_transform)
9193     branch_jmp_to_next = is_branch_jmp_to_next (&orig_tinsn, fragP);
9194
9195   if (branch_jmp_to_next && !next_frag_is_loop_target (fragP))
9196     {
9197       /* Conversion just inserts a NOP and marks the fix as completed.  */
9198       bytes = xtensa_format_length (isa, fmt);
9199       if (bytes >= 4)
9200         {
9201           orig_vinsn.slots[slot].opcode =
9202             xtensa_format_slot_nop_opcode (isa, orig_vinsn.format, slot);
9203           orig_vinsn.slots[slot].ntok = 0;
9204         }
9205       else
9206         {
9207           bytes += fragP->tc_frag_data.text_expansion[0];
9208           assert (bytes == 2 || bytes == 3);
9209           build_nop (&orig_vinsn.slots[0], bytes);
9210           fragP->fr_fix += fragP->tc_frag_data.text_expansion[0];
9211         }
9212       vinsn_to_insnbuf (&orig_vinsn, fr_opcode, frag_now, FALSE);
9213       xtensa_insnbuf_to_chars
9214         (isa, orig_vinsn.insnbuf, (unsigned char *) fr_opcode, 0);
9215       fragP->fr_var = 0;
9216     }
9217   else
9218     {
9219       /* Here is the fun stuff:  Get the immediate field from this
9220          instruction.  If it fits, we're done.  If not, find the next
9221          instruction sequence that fits.  */
9222
9223       IStack istack;
9224       int i;
9225       symbolS *lit_sym = NULL;
9226       int total_size = 0;
9227       int target_offset = 0;
9228       int old_size;
9229       int diff;
9230       symbolS *gen_label = NULL;
9231       offsetT frag_offset;
9232       bfd_boolean first = TRUE;
9233       bfd_boolean last_is_jump;
9234
9235       /* It does not fit.  Find something that does and
9236          convert immediately.  */
9237       frag_offset = fr_opcode - fragP->fr_literal;
9238       istack_init (&istack);
9239       xg_assembly_relax (&istack, &orig_tinsn,
9240                          segP, fragP, frag_offset, min_steps, 0);
9241
9242       old_size = xtensa_format_length (isa, fmt);
9243
9244       /* Assemble this right inline.  */
9245
9246       /* First, create the mapping from a label name to the REAL label.  */
9247       target_offset = 0;
9248       for (i = 0; i < istack.ninsn; i++)
9249         {
9250           TInsn *tinsn = &istack.insn[i];
9251           fragS *lit_frag;
9252
9253           switch (tinsn->insn_type)
9254             {
9255             case ITYPE_LITERAL:
9256               if (lit_sym != NULL)
9257                 as_bad (_("multiple literals in expansion"));
9258               /* First find the appropriate space in the literal pool.  */
9259               lit_frag = fragP->tc_frag_data.literal_frags[slot];
9260               if (lit_frag == NULL)
9261                 as_bad (_("no registered fragment for literal"));
9262               if (tinsn->ntok != 1)
9263                 as_bad (_("number of literal tokens != 1"));
9264
9265               /* Set the literal symbol and add a fixup.  */
9266               lit_sym = lit_frag->fr_symbol;
9267               break;
9268
9269             case ITYPE_LABEL:
9270               if (align_targets && !is_loop)
9271                 {
9272                   fragS *unreach = fragP->fr_next;
9273                   while (!(unreach->fr_type == rs_machine_dependent
9274                            && (unreach->fr_subtype == RELAX_MAYBE_UNREACHABLE
9275                                || unreach->fr_subtype == RELAX_UNREACHABLE)))
9276                     {
9277                       unreach = unreach->fr_next;
9278                     }
9279
9280                   assert (unreach->fr_type == rs_machine_dependent
9281                           && (unreach->fr_subtype == RELAX_MAYBE_UNREACHABLE
9282                               || unreach->fr_subtype == RELAX_UNREACHABLE));
9283
9284                   target_offset += unreach->tc_frag_data.text_expansion[0];
9285                 }
9286               assert (gen_label == NULL);
9287               gen_label = symbol_new (FAKE_LABEL_NAME, now_seg,
9288                                       fr_opcode - fragP->fr_literal
9289                                       + target_offset, fragP);
9290               break;
9291
9292             case ITYPE_INSN:
9293               if (first && wide_insn)
9294                 {
9295                   target_offset += xtensa_format_length (isa, fmt);
9296                   first = FALSE;
9297                   if (!opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9298                     target_offset += xg_get_single_size (tinsn->opcode);
9299                 }
9300               else
9301                 target_offset += xg_get_single_size (tinsn->opcode);
9302               break;
9303             }
9304         }
9305
9306       total_size = 0;
9307       first = TRUE;
9308       last_is_jump = FALSE;
9309       for (i = 0; i < istack.ninsn; i++)
9310         {
9311           TInsn *tinsn = &istack.insn[i];
9312           fragS *lit_frag;
9313           int size;
9314           segT target_seg;
9315           bfd_reloc_code_real_type reloc_type;
9316
9317           switch (tinsn->insn_type)
9318             {
9319             case ITYPE_LITERAL:
9320               lit_frag = fragP->tc_frag_data.literal_frags[slot];
9321               /* Already checked.  */
9322               assert (lit_frag != NULL);
9323               assert (lit_sym != NULL);
9324               assert (tinsn->ntok == 1);
9325               /* Add a fixup.  */
9326               target_seg = S_GET_SEGMENT (lit_sym);
9327               assert (target_seg);
9328               if (tinsn->tok[0].X_op == O_pltrel)
9329                 reloc_type = BFD_RELOC_XTENSA_PLT;
9330               else
9331                 reloc_type = BFD_RELOC_32;
9332               fix_new_exp_in_seg (target_seg, 0, lit_frag, 0, 4,
9333                                   &tinsn->tok[0], FALSE, reloc_type);
9334               break;
9335
9336             case ITYPE_LABEL:
9337               break;
9338
9339             case ITYPE_INSN:
9340               xg_resolve_labels (tinsn, gen_label);
9341               xg_resolve_literals (tinsn, lit_sym);
9342               if (wide_insn && first)
9343                 {
9344                   first = FALSE;
9345                   if (opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9346                     {
9347                       tinsn->record_fix = TRUE;
9348                       orig_vinsn.slots[slot] = *tinsn;
9349                     }
9350                   else
9351                     {
9352                       orig_vinsn.slots[slot].opcode =
9353                         xtensa_format_slot_nop_opcode (isa, fmt, slot);
9354                       orig_vinsn.slots[slot].ntok = 0;
9355                       orig_vinsn.slots[slot].record_fix = FALSE;
9356                     }
9357                   vinsn_to_insnbuf (&orig_vinsn, immed_instr, fragP, TRUE);
9358                   xtensa_insnbuf_to_chars (isa, orig_vinsn.insnbuf,
9359                                            (unsigned char *) immed_instr, 0);
9360                   fragP->tc_frag_data.is_insn = TRUE;
9361                   size = xtensa_format_length (isa, fmt);
9362                   if (!opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9363                     {
9364                       xtensa_format single_fmt =
9365                         xg_get_single_format (tinsn->opcode);
9366
9367                       xg_emit_insn_to_buf
9368                         (tinsn, single_fmt, immed_instr + size, fragP,
9369                          immed_instr - fragP->fr_literal + size, TRUE);
9370                       size += xg_get_single_size (tinsn->opcode);
9371                     }
9372                 }
9373               else
9374                 {
9375                   xtensa_format single_format;
9376                   size = xg_get_single_size (tinsn->opcode);
9377                   single_format = xg_get_single_format (tinsn->opcode);
9378                   xg_emit_insn_to_buf (tinsn, single_format, immed_instr,
9379                                        fragP,
9380                                        immed_instr - fragP->fr_literal, TRUE);
9381                 }
9382               immed_instr += size;
9383               total_size += size;
9384               break;
9385             }
9386         }
9387
9388       diff = total_size - old_size;
9389       assert (diff >= 0);
9390       if (diff != 0)
9391         expanded = TRUE;
9392       assert (diff <= fragP->fr_var);
9393       fragP->fr_var -= diff;
9394       fragP->fr_fix += diff;
9395     }
9396
9397   /* Clean it up.  */
9398   xg_free_vinsn (&orig_vinsn);
9399
9400   /* Check for undefined immediates in LOOP instructions.  */
9401   if (is_loop)
9402     {
9403       symbolS *sym;
9404       sym = orig_tinsn.tok[1].X_add_symbol;
9405       if (sym != NULL && !S_IS_DEFINED (sym))
9406         {
9407           as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym));
9408           return;
9409         }
9410       sym = orig_tinsn.tok[1].X_op_symbol;
9411       if (sym != NULL && !S_IS_DEFINED (sym))
9412         {
9413           as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym));
9414           return;
9415         }
9416     }
9417
9418   if (expanded && xtensa_opcode_is_loop (isa, orig_tinsn.opcode) == 1)
9419     convert_frag_immed_finish_loop (segP, fragP, &orig_tinsn);
9420
9421   if (expanded && is_direct_call_opcode (orig_tinsn.opcode))
9422     {
9423       /* Add an expansion note on the expanded instruction.  */
9424       fix_new_exp_in_seg (now_seg, 0, fragP, fr_opcode - fragP->fr_literal, 4,
9425                           &orig_tinsn.tok[0], TRUE,
9426                           BFD_RELOC_XTENSA_ASM_EXPAND);
9427     }
9428 }
9429
9430
9431 /* Add a new fix expression into the desired segment.  We have to
9432    switch to that segment to do this.  */
9433
9434 static fixS *
9435 fix_new_exp_in_seg (segT new_seg,
9436                     subsegT new_subseg,
9437                     fragS *frag,
9438                     int where,
9439                     int size,
9440                     expressionS *exp,
9441                     int pcrel,
9442                     bfd_reloc_code_real_type r_type)
9443 {
9444   fixS *new_fix;
9445   segT seg = now_seg;
9446   subsegT subseg = now_subseg;
9447
9448   assert (new_seg != 0);
9449   subseg_set (new_seg, new_subseg);
9450
9451   new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
9452   subseg_set (seg, subseg);
9453   return new_fix;
9454 }
9455
9456
9457 /* Relax a loop instruction so that it can span loop >256 bytes.
9458
9459                   loop    as, .L1
9460           .L0:
9461                   rsr     as, LEND
9462                   wsr     as, LBEG
9463                   addi    as, as, lo8 (label-.L1)
9464                   addmi   as, as, mid8 (label-.L1)
9465                   wsr     as, LEND
9466                   isync
9467                   rsr     as, LCOUNT
9468                   addi    as, as, 1
9469           .L1:
9470                   <<body>>
9471           label:
9472 */
9473
9474 static void
9475 convert_frag_immed_finish_loop (segT segP, fragS *fragP, TInsn *tinsn)
9476 {
9477   TInsn loop_insn;
9478   TInsn addi_insn;
9479   TInsn addmi_insn;
9480   unsigned long target;
9481   static xtensa_insnbuf insnbuf = NULL;
9482   unsigned int loop_length, loop_length_hi, loop_length_lo;
9483   xtensa_isa isa = xtensa_default_isa;
9484   addressT loop_offset;
9485   addressT addi_offset = 9;
9486   addressT addmi_offset = 12;
9487   fragS *next_fragP;
9488   int target_count;
9489
9490   if (!insnbuf)
9491     insnbuf = xtensa_insnbuf_alloc (isa);
9492
9493   /* Get the loop offset.  */
9494   loop_offset = get_expanded_loop_offset (tinsn->opcode);
9495
9496   /* Validate that there really is a LOOP at the loop_offset.  Because
9497      loops are not bundleable, we can assume that the instruction will be
9498      in slot 0.  */
9499   tinsn_from_chars (&loop_insn, fragP->fr_opcode + loop_offset, 0);
9500   tinsn_immed_from_frag (&loop_insn, fragP, 0);
9501
9502   assert (xtensa_opcode_is_loop (isa, loop_insn.opcode) == 1);
9503   addi_offset += loop_offset;
9504   addmi_offset += loop_offset;
9505
9506   assert (tinsn->ntok == 2);
9507   if (tinsn->tok[1].X_op == O_constant)
9508     target = tinsn->tok[1].X_add_number;
9509   else if (tinsn->tok[1].X_op == O_symbol)
9510     {
9511       /* Find the fragment.  */
9512       symbolS *sym = tinsn->tok[1].X_add_symbol;
9513       assert (S_GET_SEGMENT (sym) == segP
9514               || S_GET_SEGMENT (sym) == absolute_section);
9515       target = (S_GET_VALUE (sym) + tinsn->tok[1].X_add_number);
9516     }
9517   else
9518     {
9519       as_bad (_("invalid expression evaluation type %d"), tinsn->tok[1].X_op);
9520       target = 0;
9521     }
9522
9523   know (symbolP);
9524   know (symbolP->sy_frag);
9525   know (!(S_GET_SEGMENT (symbolP) == absolute_section)
9526         || symbol_get_frag (symbolP) == &zero_address_frag);
9527
9528   loop_length = target - (fragP->fr_address + fragP->fr_fix);
9529   loop_length_hi = loop_length & ~0x0ff;
9530   loop_length_lo = loop_length & 0x0ff;
9531   if (loop_length_lo >= 128)
9532     {
9533       loop_length_lo -= 256;
9534       loop_length_hi += 256;
9535     }
9536
9537   /* Because addmi sign-extends the immediate, 'loop_length_hi' can be at most
9538      32512.  If the loop is larger than that, then we just fail.  */
9539   if (loop_length_hi > 32512)
9540     as_bad_where (fragP->fr_file, fragP->fr_line,
9541                   _("loop too long for LOOP instruction"));
9542
9543   tinsn_from_chars (&addi_insn, fragP->fr_opcode + addi_offset, 0);
9544   assert (addi_insn.opcode == xtensa_addi_opcode);
9545
9546   tinsn_from_chars (&addmi_insn, fragP->fr_opcode + addmi_offset, 0);
9547   assert (addmi_insn.opcode == xtensa_addmi_opcode);
9548
9549   set_expr_const (&addi_insn.tok[2], loop_length_lo);
9550   tinsn_to_insnbuf (&addi_insn, insnbuf);
9551
9552   fragP->tc_frag_data.is_insn = TRUE;
9553   xtensa_insnbuf_to_chars
9554     (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addi_offset, 0);
9555
9556   set_expr_const (&addmi_insn.tok[2], loop_length_hi);
9557   tinsn_to_insnbuf (&addmi_insn, insnbuf);
9558   xtensa_insnbuf_to_chars
9559     (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addmi_offset, 0);
9560
9561   /* Walk through all of the frags from here to the loop end
9562      and mark them as no_transform to keep them from being modified
9563      by the linker.  If we ever have a relocation for the
9564      addi/addmi of the difference of two symbols we can remove this.  */
9565
9566   target_count = 0;
9567   for (next_fragP = fragP; next_fragP != NULL;
9568        next_fragP = next_fragP->fr_next)
9569     {
9570       next_fragP->tc_frag_data.is_no_transform = TRUE;
9571       if (next_fragP->tc_frag_data.is_loop_target)
9572         target_count++;
9573       if (target_count == 2)
9574         break;
9575     }
9576 }
9577
9578 \f
9579 /* A map that keeps information on a per-subsegment basis.  This is
9580    maintained during initial assembly, but is invalid once the
9581    subsegments are smashed together.  I.E., it cannot be used during
9582    the relaxation.  */
9583
9584 typedef struct subseg_map_struct
9585 {
9586   /* the key */
9587   segT seg;
9588   subsegT subseg;
9589
9590   /* the data */
9591   unsigned flags;
9592   float total_freq;     /* fall-through + branch target frequency */
9593   float target_freq;    /* branch target frequency alone */
9594
9595   struct subseg_map_struct *next;
9596 } subseg_map;
9597
9598
9599 static subseg_map *sseg_map = NULL;
9600
9601 static subseg_map *
9602 get_subseg_info (segT seg, subsegT subseg)
9603 {
9604   subseg_map *subseg_e;
9605
9606   for (subseg_e = sseg_map; subseg_e; subseg_e = subseg_e->next)
9607     {
9608       if (seg == subseg_e->seg && subseg == subseg_e->subseg)
9609         break;
9610     }
9611   return subseg_e;
9612 }
9613
9614
9615 static subseg_map *
9616 add_subseg_info (segT seg, subsegT subseg)
9617 {
9618   subseg_map *subseg_e = (subseg_map *) xmalloc (sizeof (subseg_map));
9619   memset (subseg_e, 0, sizeof (subseg_map));
9620   subseg_e->seg = seg;
9621   subseg_e->subseg = subseg;
9622   subseg_e->flags = 0;
9623   /* Start off considering every branch target very important.  */
9624   subseg_e->target_freq = 1.0;
9625   subseg_e->total_freq = 1.0;
9626   subseg_e->next = sseg_map;
9627   sseg_map = subseg_e;
9628   return subseg_e;
9629 }
9630
9631
9632 static unsigned
9633 get_last_insn_flags (segT seg, subsegT subseg)
9634 {
9635   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9636   if (subseg_e)
9637     return subseg_e->flags;
9638   return 0;
9639 }
9640
9641
9642 static void
9643 set_last_insn_flags (segT seg,
9644                      subsegT subseg,
9645                      unsigned fl,
9646                      bfd_boolean val)
9647 {
9648   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9649   if (! subseg_e)
9650     subseg_e = add_subseg_info (seg, subseg);
9651   if (val)
9652     subseg_e->flags |= fl;
9653   else
9654     subseg_e->flags &= ~fl;
9655 }
9656
9657
9658 static float
9659 get_subseg_total_freq (segT seg, subsegT subseg)
9660 {
9661   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9662   if (subseg_e)
9663     return subseg_e->total_freq;
9664   return 1.0;
9665 }
9666
9667
9668 static float
9669 get_subseg_target_freq (segT seg, subsegT subseg)
9670 {
9671   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9672   if (subseg_e)
9673     return subseg_e->target_freq;
9674   return 1.0;
9675 }
9676
9677
9678 static void
9679 set_subseg_freq (segT seg, subsegT subseg, float total_f, float target_f)
9680 {
9681   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9682   if (! subseg_e)
9683     subseg_e = add_subseg_info (seg, subseg);
9684   subseg_e->total_freq = total_f;
9685   subseg_e->target_freq = target_f;
9686 }
9687
9688 \f
9689 /* Segment Lists and emit_state Stuff.  */
9690
9691 static void
9692 xtensa_move_seg_list_to_beginning (seg_list *head)
9693 {
9694   head = head->next;
9695   while (head)
9696     {
9697       segT literal_section = head->seg;
9698
9699       /* Move the literal section to the front of the section list.  */
9700       assert (literal_section);
9701       if (literal_section != stdoutput->sections)
9702         {
9703           bfd_section_list_remove (stdoutput, literal_section);
9704           bfd_section_list_prepend (stdoutput, literal_section);
9705         }
9706       head = head->next;
9707     }
9708 }
9709
9710
9711 static void mark_literal_frags (seg_list *);
9712
9713 static void
9714 xtensa_move_literals (void)
9715 {
9716   seg_list *segment;
9717   frchainS *frchain_from, *frchain_to;
9718   fragS *search_frag, *next_frag, *last_frag, *literal_pool, *insert_after;
9719   fragS **frag_splice;
9720   emit_state state;
9721   segT dest_seg;
9722   fixS *fix, *next_fix, **fix_splice;
9723   sym_list *lit;
9724
9725   mark_literal_frags (literal_head->next);
9726   mark_literal_frags (init_literal_head->next);
9727   mark_literal_frags (fini_literal_head->next);
9728
9729   if (use_literal_section)
9730     return;
9731
9732   segment = literal_head->next;
9733   while (segment)
9734     {
9735       frchain_from = seg_info (segment->seg)->frchainP;
9736       search_frag = frchain_from->frch_root;
9737       literal_pool = NULL;
9738       frchain_to = NULL;
9739       frag_splice = &(frchain_from->frch_root);
9740
9741       while (!search_frag->tc_frag_data.literal_frag)
9742         {
9743           assert (search_frag->fr_fix == 0
9744                   || search_frag->fr_type == rs_align);
9745           search_frag = search_frag->fr_next;
9746         }
9747
9748       assert (search_frag->tc_frag_data.literal_frag->fr_subtype
9749               == RELAX_LITERAL_POOL_BEGIN);
9750       xtensa_switch_section_emit_state (&state, segment->seg, 0);
9751
9752       /* Make sure that all the frags in this series are closed, and
9753          that there is at least one left over of zero-size.  This
9754          prevents us from making a segment with an frchain without any
9755          frags in it.  */
9756       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9757       xtensa_set_frag_assembly_state (frag_now);
9758       last_frag = frag_now;
9759       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9760       xtensa_set_frag_assembly_state (frag_now);
9761
9762       while (search_frag != frag_now)
9763         {
9764           next_frag = search_frag->fr_next;
9765
9766           /* First, move the frag out of the literal section and
9767              to the appropriate place.  */
9768           if (search_frag->tc_frag_data.literal_frag)
9769             {
9770               literal_pool = search_frag->tc_frag_data.literal_frag;
9771               assert (literal_pool->fr_subtype == RELAX_LITERAL_POOL_BEGIN);
9772               frchain_to = literal_pool->tc_frag_data.lit_frchain;
9773               assert (frchain_to);
9774             }
9775           insert_after = literal_pool;
9776
9777           while (insert_after->fr_next->fr_subtype != RELAX_LITERAL_POOL_END)
9778             insert_after = insert_after->fr_next;
9779
9780           dest_seg = insert_after->fr_next->tc_frag_data.lit_seg;
9781
9782           *frag_splice = next_frag;
9783           search_frag->fr_next = insert_after->fr_next;
9784           insert_after->fr_next = search_frag;
9785           search_frag->tc_frag_data.lit_seg = dest_seg;
9786
9787           /* Now move any fixups associated with this frag to the
9788              right section.  */
9789           fix = frchain_from->fix_root;
9790           fix_splice = &(frchain_from->fix_root);
9791           while (fix)
9792             {
9793               next_fix = fix->fx_next;
9794               if (fix->fx_frag == search_frag)
9795                 {
9796                   *fix_splice = next_fix;
9797                   fix->fx_next = frchain_to->fix_root;
9798                   frchain_to->fix_root = fix;
9799                   if (frchain_to->fix_tail == NULL)
9800                     frchain_to->fix_tail = fix;
9801                 }
9802               else
9803                 fix_splice = &(fix->fx_next);
9804               fix = next_fix;
9805             }
9806           search_frag = next_frag;
9807         }
9808
9809       if (frchain_from->fix_root != NULL)
9810         {
9811           frchain_from = seg_info (segment->seg)->frchainP;
9812           as_warn (_("fixes not all moved from %s"), segment->seg->name);
9813
9814           assert (frchain_from->fix_root == NULL);
9815         }
9816       frchain_from->fix_tail = NULL;
9817       xtensa_restore_emit_state (&state);
9818       segment = segment->next;
9819     }
9820
9821   /* Now fix up the SEGMENT value for all the literal symbols.  */
9822   for (lit = literal_syms; lit; lit = lit->next)
9823     {
9824       symbolS *lit_sym = lit->sym;
9825       segT dest_seg = symbol_get_frag (lit_sym)->tc_frag_data.lit_seg;
9826       if (dest_seg)
9827         S_SET_SEGMENT (lit_sym, dest_seg);
9828     }
9829 }
9830
9831
9832 /* Walk over all the frags for segments in a list and mark them as
9833    containing literals.  As clunky as this is, we can't rely on frag_var
9834    and frag_variant to get called in all situations.  */
9835
9836 static void
9837 mark_literal_frags (seg_list *segment)
9838 {
9839   frchainS *frchain_from;
9840   fragS *search_frag;
9841
9842   while (segment)
9843     {
9844       frchain_from = seg_info (segment->seg)->frchainP;
9845       search_frag = frchain_from->frch_root;
9846       while (search_frag)
9847         {
9848           search_frag->tc_frag_data.is_literal = TRUE;
9849           search_frag = search_frag->fr_next;
9850         }
9851       segment = segment->next;
9852     }
9853 }
9854
9855
9856 static void
9857 xtensa_reorder_seg_list (seg_list *head, segT after)
9858 {
9859   /* Move all of the sections in the section list to come
9860      after "after" in the gnu segment list.  */
9861
9862   head = head->next;
9863   while (head)
9864     {
9865       segT literal_section = head->seg;
9866
9867       /* Move the literal section after "after".  */
9868       assert (literal_section);
9869       if (literal_section != after)
9870         {
9871           bfd_section_list_remove (stdoutput, literal_section);
9872           bfd_section_list_insert_after (stdoutput, after, literal_section);
9873         }
9874
9875       head = head->next;
9876     }
9877 }
9878
9879
9880 /* Push all the literal segments to the end of the gnu list.  */
9881
9882 static void
9883 xtensa_reorder_segments (void)
9884 {
9885   segT sec;
9886   segT last_sec = 0;
9887   int old_count = 0;
9888   int new_count = 0;
9889
9890   for (sec = stdoutput->sections; sec != NULL; sec = sec->next)
9891     {
9892       last_sec = sec;
9893       old_count++;
9894     }
9895
9896   /* Now that we have the last section, push all the literal
9897      sections to the end.  */
9898   xtensa_reorder_seg_list (literal_head, last_sec);
9899   xtensa_reorder_seg_list (init_literal_head, last_sec);
9900   xtensa_reorder_seg_list (fini_literal_head, last_sec);
9901
9902   /* Now perform the final error check.  */
9903   for (sec = stdoutput->sections; sec != NULL; sec = sec->next)
9904     new_count++;
9905   assert (new_count == old_count);
9906 }
9907
9908
9909 /* Change the emit state (seg, subseg, and frag related stuff) to the
9910    correct location.  Return a emit_state which can be passed to
9911    xtensa_restore_emit_state to return to current fragment.  */
9912
9913 static void
9914 xtensa_switch_to_literal_fragment (emit_state *result)
9915 {
9916   if (directive_state[directive_absolute_literals])
9917     {
9918       cache_literal_section (0, default_lit_sections.lit4_seg_name,
9919                              &default_lit_sections.lit4_seg, FALSE);
9920       xtensa_switch_section_emit_state (result,
9921                                         default_lit_sections.lit4_seg, 0);
9922     }
9923   else
9924     xtensa_switch_to_non_abs_literal_fragment (result);
9925
9926   /* Do a 4-byte align here.  */
9927   frag_align (2, 0, 0);
9928   record_alignment (now_seg, 2);
9929 }
9930
9931
9932 static void
9933 xtensa_switch_to_non_abs_literal_fragment (emit_state *result)
9934 {
9935   /* When we mark a literal pool location, we want to put a frag in
9936      the literal pool that points to it.  But to do that, we want to
9937      switch_to_literal_fragment.  But literal sections don't have
9938      literal pools, so their location is always null, so we would
9939      recurse forever.  This is kind of hacky, but it works.  */
9940
9941   static bfd_boolean recursive = FALSE;
9942   fragS *pool_location = get_literal_pool_location (now_seg);
9943   bfd_boolean is_init =
9944     (now_seg && !strcmp (segment_name (now_seg), INIT_SECTION_NAME));
9945
9946   bfd_boolean is_fini =
9947     (now_seg && !strcmp (segment_name (now_seg), FINI_SECTION_NAME));
9948
9949   if (pool_location == NULL
9950       && !use_literal_section
9951       && !recursive
9952       && !is_init && ! is_fini)
9953     {
9954       as_bad (_("literal pool location required for text-section-literals; specify with .literal_position"));
9955       recursive = TRUE;
9956       xtensa_mark_literal_pool_location ();
9957       recursive = FALSE;
9958     }
9959
9960   /* Special case: If we are in the ".fini" or ".init" section, then
9961      we will ALWAYS be generating to the ".fini.literal" and
9962      ".init.literal" sections.  */
9963
9964   if (is_init)
9965     {
9966       cache_literal_section (init_literal_head,
9967                              default_lit_sections.init_lit_seg_name,
9968                              &default_lit_sections.init_lit_seg, TRUE);
9969       xtensa_switch_section_emit_state (result,
9970                                         default_lit_sections.init_lit_seg, 0);
9971     }
9972   else if (is_fini)
9973     {
9974       cache_literal_section (fini_literal_head,
9975                              default_lit_sections.fini_lit_seg_name,
9976                              &default_lit_sections.fini_lit_seg, TRUE);
9977       xtensa_switch_section_emit_state (result,
9978                                         default_lit_sections.fini_lit_seg, 0);
9979     }
9980   else
9981     {
9982       cache_literal_section (literal_head,
9983                              default_lit_sections.lit_seg_name,
9984                              &default_lit_sections.lit_seg, TRUE);
9985       xtensa_switch_section_emit_state (result,
9986                                         default_lit_sections.lit_seg, 0);
9987     }
9988
9989   if (!use_literal_section
9990       && !is_init && !is_fini
9991       && get_literal_pool_location (now_seg) != pool_location)
9992     {
9993       /* Close whatever frag is there.  */
9994       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9995       xtensa_set_frag_assembly_state (frag_now);
9996       frag_now->tc_frag_data.literal_frag = pool_location;
9997       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9998       xtensa_set_frag_assembly_state (frag_now);
9999     }
10000 }
10001
10002
10003 /* Call this function before emitting data into the literal section.
10004    This is a helper function for xtensa_switch_to_literal_fragment.
10005    This is similar to a .section new_now_seg subseg. */
10006
10007 static void
10008 xtensa_switch_section_emit_state (emit_state *state,
10009                                   segT new_now_seg,
10010                                   subsegT new_now_subseg)
10011 {
10012   state->name = now_seg->name;
10013   state->now_seg = now_seg;
10014   state->now_subseg = now_subseg;
10015   state->generating_literals = generating_literals;
10016   generating_literals++;
10017   subseg_set (new_now_seg, new_now_subseg);
10018 }
10019
10020
10021 /* Use to restore the emitting into the normal place.  */
10022
10023 static void
10024 xtensa_restore_emit_state (emit_state *state)
10025 {
10026   generating_literals = state->generating_literals;
10027   subseg_set (state->now_seg, state->now_subseg);
10028 }
10029
10030
10031 /* Get a segment of a given name.  If the segment is already
10032    present, return it; otherwise, create a new one.  */
10033
10034 static void
10035 cache_literal_section (seg_list *head,
10036                        const char *name,
10037                        segT *pseg,
10038                        bfd_boolean is_code)
10039 {
10040   segT current_section = now_seg;
10041   int current_subsec = now_subseg;
10042   segT seg;
10043
10044   if (*pseg != 0)
10045     return;
10046
10047   /* Check if the named section exists.  */
10048   for (seg = stdoutput->sections; seg; seg = seg->next)
10049     {
10050       if (!strcmp (segment_name (seg), name))
10051         break;
10052     }
10053
10054   if (!seg)
10055     {
10056       /* Create a new literal section.  */
10057       seg = subseg_new (name, (subsegT) 0);
10058       if (head)
10059         {
10060           /* Add the newly created literal segment to the specified list.  */
10061           seg_list *n = (seg_list *) xmalloc (sizeof (seg_list));
10062           n->seg = seg;
10063           n->next = head->next;
10064           head->next = n;
10065         }
10066       bfd_set_section_flags (stdoutput, seg, SEC_HAS_CONTENTS |
10067                              SEC_READONLY | SEC_ALLOC | SEC_LOAD
10068                              | (is_code ? SEC_CODE : SEC_DATA));
10069       bfd_set_section_alignment (stdoutput, seg, 2);
10070     }
10071
10072   *pseg = seg;
10073   subseg_set (current_section, current_subsec);
10074 }
10075
10076 \f
10077 /* Property Tables Stuff.  */
10078
10079 #define XTENSA_INSN_SEC_NAME ".xt.insn"
10080 #define XTENSA_LIT_SEC_NAME ".xt.lit"
10081 #define XTENSA_PROP_SEC_NAME ".xt.prop"
10082
10083 typedef bfd_boolean (*frag_predicate) (const fragS *);
10084 typedef void (*frag_flags_fn) (const fragS *, frag_flags *);
10085
10086 static bfd_boolean get_frag_is_literal (const fragS *);
10087 static void xtensa_create_property_segments
10088   (frag_predicate, frag_predicate, const char *, xt_section_type);
10089 static void xtensa_create_xproperty_segments
10090   (frag_flags_fn, const char *, xt_section_type);
10091 static segment_info_type *retrieve_segment_info (segT);
10092 static segT retrieve_xtensa_section (char *);
10093 static bfd_boolean section_has_property (segT, frag_predicate);
10094 static bfd_boolean section_has_xproperty (segT, frag_flags_fn);
10095 static void add_xt_block_frags
10096   (segT, segT, xtensa_block_info **, frag_predicate, frag_predicate);
10097 static bfd_boolean xtensa_frag_flags_is_empty (const frag_flags *);
10098 static void xtensa_frag_flags_init (frag_flags *);
10099 static void get_frag_property_flags (const fragS *, frag_flags *);
10100 static bfd_vma frag_flags_to_number (const frag_flags *);
10101 static void add_xt_prop_frags
10102   (segT, segT, xtensa_block_info **, frag_flags_fn);
10103
10104 /* Set up property tables after relaxation.  */
10105
10106 void
10107 xtensa_post_relax_hook (void)
10108 {
10109   xtensa_move_seg_list_to_beginning (literal_head);
10110   xtensa_move_seg_list_to_beginning (init_literal_head);
10111   xtensa_move_seg_list_to_beginning (fini_literal_head);
10112
10113   xtensa_find_unmarked_state_frags ();
10114
10115   if (use_literal_section)
10116     xtensa_create_property_segments (get_frag_is_literal,
10117                                      NULL,
10118                                      XTENSA_LIT_SEC_NAME,
10119                                      xt_literal_sec);
10120   xtensa_create_xproperty_segments (get_frag_property_flags,
10121                                     XTENSA_PROP_SEC_NAME,
10122                                     xt_prop_sec);
10123
10124   if (warn_unaligned_branch_targets)
10125     bfd_map_over_sections (stdoutput, xtensa_find_unaligned_branch_targets, 0);
10126   bfd_map_over_sections (stdoutput, xtensa_find_unaligned_loops, 0);
10127 }
10128
10129
10130 /* This function is only meaningful after xtensa_move_literals.  */
10131
10132 static bfd_boolean
10133 get_frag_is_literal (const fragS *fragP)
10134 {
10135   assert (fragP != NULL);
10136   return fragP->tc_frag_data.is_literal;
10137 }
10138
10139
10140 static void
10141 xtensa_create_property_segments (frag_predicate property_function,
10142                                  frag_predicate end_property_function,
10143                                  const char *section_name_base,
10144                                  xt_section_type sec_type)
10145 {
10146   segT *seclist;
10147
10148   /* Walk over all of the current segments.
10149      Walk over each fragment
10150      For each non-empty fragment,
10151      Build a property record (append where possible).  */
10152
10153   for (seclist = &stdoutput->sections;
10154        seclist && *seclist;
10155        seclist = &(*seclist)->next)
10156     {
10157       segT sec = *seclist;
10158       flagword flags;
10159
10160       flags = bfd_get_section_flags (stdoutput, sec);
10161       if (flags & SEC_DEBUGGING)
10162         continue;
10163       if (!(flags & SEC_ALLOC))
10164         continue;
10165
10166       if (section_has_property (sec, property_function))
10167         {
10168           char *property_section_name =
10169             xtensa_get_property_section_name (sec, section_name_base);
10170           segT insn_sec = retrieve_xtensa_section (property_section_name);
10171           segment_info_type *xt_seg_info = retrieve_segment_info (insn_sec);
10172           xtensa_block_info **xt_blocks =
10173             &xt_seg_info->tc_segment_info_data.blocks[sec_type];
10174           /* Walk over all of the frchains here and add new sections.  */
10175           add_xt_block_frags (sec, insn_sec, xt_blocks, property_function,
10176                               end_property_function);
10177         }
10178     }
10179
10180   /* Now we fill them out....  */
10181
10182   for (seclist = &stdoutput->sections;
10183        seclist && *seclist;
10184        seclist = &(*seclist)->next)
10185     {
10186       segment_info_type *seginfo;
10187       xtensa_block_info *block;
10188       segT sec = *seclist;
10189
10190       seginfo = seg_info (sec);
10191       block = seginfo->tc_segment_info_data.blocks[sec_type];
10192
10193       if (block)
10194         {
10195           xtensa_block_info *cur_block;
10196           /* This is a section with some data.  */
10197           int num_recs = 0;
10198           bfd_size_type rec_size;
10199
10200           for (cur_block = block; cur_block; cur_block = cur_block->next)
10201             num_recs++;
10202
10203           rec_size = num_recs * 8;
10204           bfd_set_section_size (stdoutput, sec, rec_size);
10205
10206           /* In order to make this work with the assembler, we have to
10207              build some frags and then build the "fixups" for it.  It
10208              would be easier to just set the contents then set the
10209              arlents.  */
10210
10211           if (num_recs)
10212             {
10213               /* Allocate a fragment and leak it.  */
10214               fragS *fragP;
10215               bfd_size_type frag_size;
10216               fixS *fixes;
10217               frchainS *frchainP;
10218               int i;
10219               char *frag_data;
10220
10221               frag_size = sizeof (fragS) + rec_size;
10222               fragP = (fragS *) xmalloc (frag_size);
10223
10224               memset (fragP, 0, frag_size);
10225               fragP->fr_address = 0;
10226               fragP->fr_next = NULL;
10227               fragP->fr_fix = rec_size;
10228               fragP->fr_var = 0;
10229               fragP->fr_type = rs_fill;
10230               /* The rest are zeros.  */
10231
10232               frchainP = seginfo->frchainP;
10233               frchainP->frch_root = fragP;
10234               frchainP->frch_last = fragP;
10235
10236               fixes = (fixS *) xmalloc (sizeof (fixS) * num_recs);
10237               memset (fixes, 0, sizeof (fixS) * num_recs);
10238
10239               seginfo->fix_root = fixes;
10240               seginfo->fix_tail = &fixes[num_recs - 1];
10241               cur_block = block;
10242               frag_data = &fragP->fr_literal[0];
10243               for (i = 0; i < num_recs; i++)
10244                 {
10245                   fixS *fix = &fixes[i];
10246                   assert (cur_block);
10247
10248                   /* Write the fixup.  */
10249                   if (i != num_recs - 1)
10250                     fix->fx_next = &fixes[i + 1];
10251                   else
10252                     fix->fx_next = NULL;
10253                   fix->fx_size = 4;
10254                   fix->fx_done = 0;
10255                   fix->fx_frag = fragP;
10256                   fix->fx_where = i * 8;
10257                   fix->fx_addsy = section_symbol (cur_block->sec);
10258                   fix->fx_offset = cur_block->offset;
10259                   fix->fx_r_type = BFD_RELOC_32;
10260                   fix->fx_file = "Internal Assembly";
10261                   fix->fx_line = 0;
10262
10263                   /* Write the length.  */
10264                   md_number_to_chars (&frag_data[4 + 8 * i],
10265                                       cur_block->size, 4);
10266                   cur_block = cur_block->next;
10267                 }
10268             }
10269         }
10270     }
10271 }
10272
10273
10274 static void
10275 xtensa_create_xproperty_segments (frag_flags_fn flag_fn,
10276                                   const char *section_name_base,
10277                                   xt_section_type sec_type)
10278 {
10279   segT *seclist;
10280
10281   /* Walk over all of the current segments.
10282      Walk over each fragment.
10283      For each fragment that has instructions,
10284      build an instruction record (append where possible).  */
10285
10286   for (seclist = &stdoutput->sections;
10287        seclist && *seclist;
10288        seclist = &(*seclist)->next)
10289     {
10290       segT sec = *seclist;
10291       flagword flags;
10292
10293       flags = bfd_get_section_flags (stdoutput, sec);
10294       if ((flags & SEC_DEBUGGING)
10295           || !(flags & SEC_ALLOC)
10296           || (flags & SEC_MERGE))
10297         continue;
10298
10299       if (section_has_xproperty (sec, flag_fn))
10300         {
10301           char *property_section_name =
10302             xtensa_get_property_section_name (sec, section_name_base);
10303           segT insn_sec = retrieve_xtensa_section (property_section_name);
10304           segment_info_type *xt_seg_info = retrieve_segment_info (insn_sec);
10305           xtensa_block_info **xt_blocks =
10306             &xt_seg_info->tc_segment_info_data.blocks[sec_type];
10307           /* Walk over all of the frchains here and add new sections.  */
10308           add_xt_prop_frags (sec, insn_sec, xt_blocks, flag_fn);
10309         }
10310     }
10311
10312   /* Now we fill them out....  */
10313
10314   for (seclist = &stdoutput->sections;
10315        seclist && *seclist;
10316        seclist = &(*seclist)->next)
10317     {
10318       segment_info_type *seginfo;
10319       xtensa_block_info *block;
10320       segT sec = *seclist;
10321
10322       seginfo = seg_info (sec);
10323       block = seginfo->tc_segment_info_data.blocks[sec_type];
10324
10325       if (block)
10326         {
10327           xtensa_block_info *cur_block;
10328           /* This is a section with some data.  */
10329           int num_recs = 0;
10330           bfd_size_type rec_size;
10331
10332           for (cur_block = block; cur_block; cur_block = cur_block->next)
10333             num_recs++;
10334
10335           rec_size = num_recs * (8 + 4);
10336           bfd_set_section_size (stdoutput, sec, rec_size);
10337
10338           /* elf_section_data (sec)->this_hdr.sh_entsize = 12; */
10339
10340           /* In order to make this work with the assembler, we have to build
10341              some frags then build the "fixups" for it.  It would be easier to
10342              just set the contents then set the arlents.  */
10343
10344           if (num_recs)
10345             {
10346               /* Allocate a fragment and (unfortunately) leak it.  */
10347               fragS *fragP;
10348               bfd_size_type frag_size;
10349               fixS *fixes;
10350               frchainS *frchainP;
10351               int i;
10352               char *frag_data;
10353
10354               frag_size = sizeof (fragS) + rec_size;
10355               fragP = (fragS *) xmalloc (frag_size);
10356
10357               memset (fragP, 0, frag_size);
10358               fragP->fr_address = 0;
10359               fragP->fr_next = NULL;
10360               fragP->fr_fix = rec_size;
10361               fragP->fr_var = 0;
10362               fragP->fr_type = rs_fill;
10363               /* The rest are zeros.  */
10364
10365               frchainP = seginfo->frchainP;
10366               frchainP->frch_root = fragP;
10367               frchainP->frch_last = fragP;
10368
10369               fixes = (fixS *) xmalloc (sizeof (fixS) * num_recs);
10370               memset (fixes, 0, sizeof (fixS) * num_recs);
10371
10372               seginfo->fix_root = fixes;
10373               seginfo->fix_tail = &fixes[num_recs - 1];
10374               cur_block = block;
10375               frag_data = &fragP->fr_literal[0];
10376               for (i = 0; i < num_recs; i++)
10377                 {
10378                   fixS *fix = &fixes[i];
10379                   assert (cur_block);
10380
10381                   /* Write the fixup.  */
10382                   if (i != num_recs - 1)
10383                     fix->fx_next = &fixes[i + 1];
10384                   else
10385                     fix->fx_next = NULL;
10386                   fix->fx_size = 4;
10387                   fix->fx_done = 0;
10388                   fix->fx_frag = fragP;
10389                   fix->fx_where = i * (8 + 4);
10390                   fix->fx_addsy = section_symbol (cur_block->sec);
10391                   fix->fx_offset = cur_block->offset;
10392                   fix->fx_r_type = BFD_RELOC_32;
10393                   fix->fx_file = "Internal Assembly";
10394                   fix->fx_line = 0;
10395
10396                   /* Write the length.  */
10397                   md_number_to_chars (&frag_data[4 + (8+4) * i],
10398                                       cur_block->size, 4);
10399                   md_number_to_chars (&frag_data[8 + (8+4) * i],
10400                                       frag_flags_to_number (&cur_block->flags),
10401                                       4);
10402                   cur_block = cur_block->next;
10403                 }
10404             }
10405         }
10406     }
10407 }
10408
10409
10410 static segment_info_type *
10411 retrieve_segment_info (segT seg)
10412 {
10413   segment_info_type *seginfo;
10414   seginfo = (segment_info_type *) bfd_get_section_userdata (stdoutput, seg);
10415   if (!seginfo)
10416     {
10417       frchainS *frchainP;
10418
10419       seginfo = (segment_info_type *) xmalloc (sizeof (*seginfo));
10420       memset ((void *) seginfo, 0, sizeof (*seginfo));
10421       seginfo->fix_root = NULL;
10422       seginfo->fix_tail = NULL;
10423       seginfo->bfd_section = seg;
10424       seginfo->sym = 0;
10425       /* We will not be dealing with these, only our special ones.  */
10426       bfd_set_section_userdata (stdoutput, seg, (void *) seginfo);
10427
10428       frchainP = (frchainS *) xmalloc (sizeof (frchainS));
10429       frchainP->frch_root = NULL;
10430       frchainP->frch_last = NULL;
10431       frchainP->frch_next = NULL;
10432       frchainP->frch_seg = seg;
10433       frchainP->frch_subseg = 0;
10434       frchainP->fix_root = NULL;
10435       frchainP->fix_tail = NULL;
10436       /* Do not init the objstack.  */
10437       /* obstack_begin (&frchainP->frch_obstack, chunksize); */
10438       /* frchainP->frch_frag_now = fragP; */
10439       frchainP->frch_frag_now = NULL;
10440
10441       seginfo->frchainP = frchainP;
10442     }
10443
10444   return seginfo;
10445 }
10446
10447
10448 static segT
10449 retrieve_xtensa_section (char *sec_name)
10450 {
10451   bfd *abfd = stdoutput;
10452   flagword flags, out_flags, link_once_flags;
10453   segT s;
10454
10455   flags = bfd_get_section_flags (abfd, now_seg);
10456   link_once_flags = (flags & SEC_LINK_ONCE);
10457   if (link_once_flags)
10458     link_once_flags |= (flags & SEC_LINK_DUPLICATES);
10459   out_flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY | link_once_flags);
10460
10461   s = bfd_make_section_old_way (abfd, sec_name);
10462   if (s == NULL)
10463     as_bad (_("could not create section %s"), sec_name);
10464   if (!bfd_set_section_flags (abfd, s, out_flags))
10465     as_bad (_("invalid flag combination on section %s"), sec_name);
10466
10467   return s;
10468 }
10469
10470
10471 static bfd_boolean
10472 section_has_property (segT sec, frag_predicate property_function)
10473 {
10474   segment_info_type *seginfo = seg_info (sec);
10475   fragS *fragP;
10476
10477   if (seginfo && seginfo->frchainP)
10478     {
10479       for (fragP = seginfo->frchainP->frch_root; fragP; fragP = fragP->fr_next)
10480         {
10481           if (property_function (fragP)
10482               && (fragP->fr_type != rs_fill || fragP->fr_fix != 0))
10483             return TRUE;
10484         }
10485     }
10486   return FALSE;
10487 }
10488
10489
10490 static bfd_boolean
10491 section_has_xproperty (segT sec, frag_flags_fn property_function)
10492 {
10493   segment_info_type *seginfo = seg_info (sec);
10494   fragS *fragP;
10495
10496   if (seginfo && seginfo->frchainP)
10497     {
10498       for (fragP = seginfo->frchainP->frch_root; fragP; fragP = fragP->fr_next)
10499         {
10500           frag_flags prop_flags;
10501           property_function (fragP, &prop_flags);
10502           if (!xtensa_frag_flags_is_empty (&prop_flags))
10503             return TRUE;
10504         }
10505     }
10506   return FALSE;
10507 }
10508
10509
10510 /* Two types of block sections exist right now: literal and insns.  */
10511
10512 static void
10513 add_xt_block_frags (segT sec,
10514                     segT xt_block_sec,
10515                     xtensa_block_info **xt_block,
10516                     frag_predicate property_function,
10517                     frag_predicate end_property_function)
10518 {
10519   segment_info_type *seg_info;
10520   segment_info_type *xt_seg_info;
10521   bfd_vma seg_offset;
10522   fragS *fragP;
10523
10524   xt_seg_info = retrieve_segment_info (xt_block_sec);
10525   seg_info = retrieve_segment_info (sec);
10526
10527   /* Build it if needed.  */
10528   while (*xt_block != NULL)
10529     xt_block = &(*xt_block)->next;
10530   /* We are either at NULL at the beginning or at the end.  */
10531
10532   /* Walk through the frags.  */
10533   seg_offset = 0;
10534
10535   if (seg_info->frchainP)
10536     {
10537       for (fragP = seg_info->frchainP->frch_root;
10538            fragP;
10539            fragP = fragP->fr_next)
10540         {
10541           if (property_function (fragP)
10542               && (fragP->fr_type != rs_fill || fragP->fr_fix != 0))
10543             {
10544               if (*xt_block != NULL)
10545                 {
10546                   if ((*xt_block)->offset + (*xt_block)->size
10547                       == fragP->fr_address)
10548                     (*xt_block)->size += fragP->fr_fix;
10549                   else
10550                     xt_block = &((*xt_block)->next);
10551                 }
10552               if (*xt_block == NULL)
10553                 {
10554                   xtensa_block_info *new_block = (xtensa_block_info *)
10555                     xmalloc (sizeof (xtensa_block_info));
10556                   new_block->sec = sec;
10557                   new_block->offset = fragP->fr_address;
10558                   new_block->size = fragP->fr_fix;
10559                   new_block->next = NULL;
10560                   xtensa_frag_flags_init (&new_block->flags);
10561                   *xt_block = new_block;
10562                 }
10563               if (end_property_function
10564                   && end_property_function (fragP))
10565                 {
10566                   xt_block = &((*xt_block)->next);
10567                 }
10568             }
10569         }
10570     }
10571 }
10572
10573
10574 /* Break the encapsulation of add_xt_prop_frags here.  */
10575
10576 static bfd_boolean
10577 xtensa_frag_flags_is_empty (const frag_flags *prop_flags)
10578 {
10579   if (prop_flags->is_literal
10580       || prop_flags->is_insn
10581       || prop_flags->is_data
10582       || prop_flags->is_unreachable)
10583     return FALSE;
10584   return TRUE;
10585 }
10586
10587
10588 static void
10589 xtensa_frag_flags_init (frag_flags *prop_flags)
10590 {
10591   memset (prop_flags, 0, sizeof (frag_flags));
10592 }
10593
10594
10595 static void
10596 get_frag_property_flags (const fragS *fragP, frag_flags *prop_flags)
10597 {
10598   xtensa_frag_flags_init (prop_flags);
10599   if (fragP->tc_frag_data.is_literal)
10600     prop_flags->is_literal = TRUE;
10601   if (fragP->tc_frag_data.is_unreachable)
10602     prop_flags->is_unreachable = TRUE;
10603   else if (fragP->tc_frag_data.is_insn)
10604     {
10605       prop_flags->is_insn = TRUE;
10606       if (fragP->tc_frag_data.is_loop_target)
10607         prop_flags->insn.is_loop_target = TRUE;
10608       if (fragP->tc_frag_data.is_branch_target)
10609         prop_flags->insn.is_branch_target = TRUE;
10610       if (fragP->tc_frag_data.is_specific_opcode
10611           || fragP->tc_frag_data.is_no_transform)
10612         prop_flags->insn.is_no_transform = TRUE;
10613       if (fragP->tc_frag_data.is_no_density)
10614         prop_flags->insn.is_no_density = TRUE;
10615       if (fragP->tc_frag_data.use_absolute_literals)
10616         prop_flags->insn.is_abslit = TRUE;
10617     }
10618   if (fragP->tc_frag_data.is_align)
10619     {
10620       prop_flags->is_align = TRUE;
10621       prop_flags->alignment = fragP->tc_frag_data.alignment;
10622       if (xtensa_frag_flags_is_empty (prop_flags))
10623         prop_flags->is_data = TRUE;
10624     }
10625 }
10626
10627
10628 static bfd_vma
10629 frag_flags_to_number (const frag_flags *prop_flags)
10630 {
10631   bfd_vma num = 0;
10632   if (prop_flags->is_literal)
10633     num |= XTENSA_PROP_LITERAL;
10634   if (prop_flags->is_insn)
10635     num |= XTENSA_PROP_INSN;
10636   if (prop_flags->is_data)
10637     num |= XTENSA_PROP_DATA;
10638   if (prop_flags->is_unreachable)
10639     num |= XTENSA_PROP_UNREACHABLE;
10640   if (prop_flags->insn.is_loop_target)
10641     num |= XTENSA_PROP_INSN_LOOP_TARGET;
10642   if (prop_flags->insn.is_branch_target)
10643     {
10644       num |= XTENSA_PROP_INSN_BRANCH_TARGET;
10645       num = SET_XTENSA_PROP_BT_ALIGN (num, prop_flags->insn.bt_align_priority);
10646     }
10647
10648   if (prop_flags->insn.is_no_density)
10649     num |= XTENSA_PROP_INSN_NO_DENSITY;
10650   if (prop_flags->insn.is_no_transform)
10651     num |= XTENSA_PROP_INSN_NO_TRANSFORM;
10652   if (prop_flags->insn.is_no_reorder)
10653     num |= XTENSA_PROP_INSN_NO_REORDER;
10654   if (prop_flags->insn.is_abslit)
10655     num |= XTENSA_PROP_INSN_ABSLIT;
10656
10657   if (prop_flags->is_align)
10658     {
10659       num |= XTENSA_PROP_ALIGN;
10660       num = SET_XTENSA_PROP_ALIGNMENT (num, prop_flags->alignment);
10661     }
10662
10663   return num;
10664 }
10665
10666
10667 static bfd_boolean
10668 xtensa_frag_flags_combinable (const frag_flags *prop_flags_1,
10669                               const frag_flags *prop_flags_2)
10670 {
10671   /* Cannot combine with an end marker.  */
10672
10673   if (prop_flags_1->is_literal != prop_flags_2->is_literal)
10674     return FALSE;
10675   if (prop_flags_1->is_insn != prop_flags_2->is_insn)
10676     return FALSE;
10677   if (prop_flags_1->is_data != prop_flags_2->is_data)
10678     return FALSE;
10679
10680   if (prop_flags_1->is_insn)
10681     {
10682       /* Properties of the beginning of the frag.  */
10683       if (prop_flags_2->insn.is_loop_target)
10684         return FALSE;
10685       if (prop_flags_2->insn.is_branch_target)
10686         return FALSE;
10687       if (prop_flags_1->insn.is_no_density !=
10688           prop_flags_2->insn.is_no_density)
10689         return FALSE;
10690       if (prop_flags_1->insn.is_no_transform !=
10691           prop_flags_2->insn.is_no_transform)
10692         return FALSE;
10693       if (prop_flags_1->insn.is_no_reorder !=
10694           prop_flags_2->insn.is_no_reorder)
10695         return FALSE;
10696       if (prop_flags_1->insn.is_abslit !=
10697           prop_flags_2->insn.is_abslit)
10698         return FALSE;
10699     }
10700
10701   if (prop_flags_1->is_align)
10702     return FALSE;
10703
10704   return TRUE;
10705 }
10706
10707
10708 static bfd_vma
10709 xt_block_aligned_size (const xtensa_block_info *xt_block)
10710 {
10711   bfd_vma end_addr;
10712   unsigned align_bits;
10713
10714   if (!xt_block->flags.is_align)
10715     return xt_block->size;
10716
10717   end_addr = xt_block->offset + xt_block->size;
10718   align_bits = xt_block->flags.alignment;
10719   end_addr = ((end_addr + ((1 << align_bits) -1)) >> align_bits) << align_bits;
10720   return end_addr - xt_block->offset;
10721 }
10722
10723
10724 static bfd_boolean
10725 xtensa_xt_block_combine (xtensa_block_info *xt_block,
10726                          const xtensa_block_info *xt_block_2)
10727 {
10728   if (xt_block->sec != xt_block_2->sec)
10729     return FALSE;
10730   if (xt_block->offset + xt_block_aligned_size (xt_block)
10731       != xt_block_2->offset)
10732     return FALSE;
10733
10734   if (xt_block_2->size == 0
10735       && (!xt_block_2->flags.is_unreachable
10736           || xt_block->flags.is_unreachable))
10737     {
10738       if (xt_block_2->flags.is_align
10739           && xt_block->flags.is_align)
10740         {
10741           /* Nothing needed.  */
10742           if (xt_block->flags.alignment >= xt_block_2->flags.alignment)
10743             return TRUE;
10744         }
10745       else
10746         {
10747           if (xt_block_2->flags.is_align)
10748             {
10749               /* Push alignment to previous entry.  */
10750               xt_block->flags.is_align = xt_block_2->flags.is_align;
10751               xt_block->flags.alignment = xt_block_2->flags.alignment;
10752             }
10753           return TRUE;
10754         }
10755     }
10756   if (!xtensa_frag_flags_combinable (&xt_block->flags,
10757                                      &xt_block_2->flags))
10758     return FALSE;
10759
10760   xt_block->size += xt_block_2->size;
10761
10762   if (xt_block_2->flags.is_align)
10763     {
10764       xt_block->flags.is_align = TRUE;
10765       xt_block->flags.alignment = xt_block_2->flags.alignment;
10766     }
10767
10768   return TRUE;
10769 }
10770
10771
10772 static void
10773 add_xt_prop_frags (segT sec,
10774                    segT xt_block_sec,
10775                    xtensa_block_info **xt_block,
10776                    frag_flags_fn property_function)
10777 {
10778   segment_info_type *seg_info;
10779   segment_info_type *xt_seg_info;
10780   bfd_vma seg_offset;
10781   fragS *fragP;
10782
10783   xt_seg_info = retrieve_segment_info (xt_block_sec);
10784   seg_info = retrieve_segment_info (sec);
10785   /* Build it if needed.  */
10786   while (*xt_block != NULL)
10787     {
10788       xt_block = &(*xt_block)->next;
10789     }
10790   /* We are either at NULL at the beginning or at the end.  */
10791
10792   /* Walk through the frags.  */
10793   seg_offset = 0;
10794
10795   if (seg_info->frchainP)
10796     {
10797       for (fragP = seg_info->frchainP->frch_root; fragP;
10798            fragP = fragP->fr_next)
10799         {
10800           xtensa_block_info tmp_block;
10801           tmp_block.sec = sec;
10802           tmp_block.offset = fragP->fr_address;
10803           tmp_block.size = fragP->fr_fix;
10804           tmp_block.next = NULL;
10805           property_function (fragP, &tmp_block.flags);
10806
10807           if (!xtensa_frag_flags_is_empty (&tmp_block.flags))
10808             /* && fragP->fr_fix != 0) */
10809             {
10810               if ((*xt_block) == NULL
10811                   || !xtensa_xt_block_combine (*xt_block, &tmp_block))
10812                 {
10813                   xtensa_block_info *new_block;
10814                   if ((*xt_block) != NULL)
10815                     xt_block = &(*xt_block)->next;
10816                   new_block = (xtensa_block_info *)
10817                     xmalloc (sizeof (xtensa_block_info));
10818                   *new_block = tmp_block;
10819                   *xt_block = new_block;
10820                 }
10821             }
10822         }
10823     }
10824 }
10825
10826 \f
10827 /* op_placement_info_table */
10828
10829 /* op_placement_info makes it easier to determine which
10830    ops can go in which slots.  */
10831
10832 static void
10833 init_op_placement_info_table (void)
10834 {
10835   xtensa_isa isa = xtensa_default_isa;
10836   xtensa_insnbuf ibuf = xtensa_insnbuf_alloc (isa);
10837   xtensa_opcode opcode;
10838   xtensa_format fmt;
10839   int slot;
10840   int num_opcodes = xtensa_isa_num_opcodes (isa);
10841
10842   op_placement_table = (op_placement_info_table)
10843     xmalloc (sizeof (op_placement_info) * num_opcodes);
10844   assert (xtensa_isa_num_formats (isa) < MAX_FORMATS);
10845
10846   for (opcode = 0; opcode < num_opcodes; opcode++)
10847     {
10848       op_placement_info *opi = &op_placement_table[opcode];
10849       /* FIXME: Make tinsn allocation dynamic.  */
10850       if (xtensa_opcode_num_operands (isa, opcode) >= MAX_INSN_ARGS)
10851         as_fatal (_("too many operands in instruction"));
10852       opi->single = XTENSA_UNDEFINED;
10853       opi->single_size = 0;
10854       opi->widest = XTENSA_UNDEFINED;
10855       opi->widest_size = 0;
10856       opi->narrowest = XTENSA_UNDEFINED;
10857       opi->narrowest_size = 0x7F;
10858       opi->formats = 0;
10859       opi->num_formats = 0;
10860       opi->issuef = 0;
10861       for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
10862         {
10863           opi->slots[fmt] = 0;
10864           for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
10865             {
10866               if (xtensa_opcode_encode (isa, fmt, slot, ibuf, opcode) == 0)
10867                 {
10868                   int fmt_length = xtensa_format_length (isa, fmt);
10869                   opi->issuef++;
10870                   set_bit (fmt, opi->formats);
10871                   set_bit (slot, opi->slots[fmt]);
10872                   /* opi->slot_count[fmt]++; */
10873                   if (fmt_length < opi->narrowest_size)
10874                     {
10875                       opi->narrowest = fmt;
10876                       opi->narrowest_size = fmt_length;
10877                     }
10878                   if (fmt_length > opi->widest_size)
10879                     {
10880                       opi->widest = fmt;
10881                       opi->widest_size = fmt_length;
10882                     }
10883                   if (xtensa_format_num_slots (isa, fmt) == 1)
10884                     {
10885                       if (opi->single_size == 0
10886                           || fmt_length < opi->single_size)
10887                         {
10888                           opi->single = fmt;
10889                           opi->single_size = fmt_length;
10890                         }
10891                     }
10892                 }
10893             }
10894           if (opi->formats)
10895             opi->num_formats++;
10896         }
10897     }
10898   xtensa_insnbuf_free (isa, ibuf);
10899 }
10900
10901
10902 bfd_boolean
10903 opcode_fits_format_slot (xtensa_opcode opcode, xtensa_format fmt, int slot)
10904 {
10905   return bit_is_set (slot, op_placement_table[opcode].slots[fmt]);
10906 }
10907
10908
10909 /* If the opcode is available in a single slot format, return its size.  */
10910
10911 static int
10912 xg_get_single_size (xtensa_opcode opcode)
10913 {
10914   assert (op_placement_table[opcode].single != XTENSA_UNDEFINED);
10915   return op_placement_table[opcode].single_size;
10916 }
10917
10918
10919 static xtensa_format
10920 xg_get_single_format (xtensa_opcode opcode)
10921 {
10922   return op_placement_table[opcode].single;
10923 }
10924
10925 \f
10926 /* Instruction Stack Functions (from "xtensa-istack.h").  */
10927
10928 void
10929 istack_init (IStack *stack)
10930 {
10931   memset (stack, 0, sizeof (IStack));
10932   stack->ninsn = 0;
10933 }
10934
10935
10936 bfd_boolean
10937 istack_empty (IStack *stack)
10938 {
10939   return (stack->ninsn == 0);
10940 }
10941
10942
10943 bfd_boolean
10944 istack_full (IStack *stack)
10945 {
10946   return (stack->ninsn == MAX_ISTACK);
10947 }
10948
10949
10950 /* Return a pointer to the top IStack entry.
10951    It is an error to call this if istack_empty () is TRUE. */
10952
10953 TInsn *
10954 istack_top (IStack *stack)
10955 {
10956   int rec = stack->ninsn - 1;
10957   assert (!istack_empty (stack));
10958   return &stack->insn[rec];
10959 }
10960
10961
10962 /* Add a new TInsn to an IStack.
10963    It is an error to call this if istack_full () is TRUE.  */
10964
10965 void
10966 istack_push (IStack *stack, TInsn *insn)
10967 {
10968   int rec = stack->ninsn;
10969   assert (!istack_full (stack));
10970   stack->insn[rec] = *insn;
10971   stack->ninsn++;
10972 }
10973
10974
10975 /* Clear space for the next TInsn on the IStack and return a pointer
10976    to it.  It is an error to call this if istack_full () is TRUE.  */
10977
10978 TInsn *
10979 istack_push_space (IStack *stack)
10980 {
10981   int rec = stack->ninsn;
10982   TInsn *insn;
10983   assert (!istack_full (stack));
10984   insn = &stack->insn[rec];
10985   memset (insn, 0, sizeof (TInsn));
10986   stack->ninsn++;
10987   return insn;
10988 }
10989
10990
10991 /* Remove the last pushed instruction.  It is an error to call this if
10992    istack_empty () returns TRUE.  */
10993
10994 void
10995 istack_pop (IStack *stack)
10996 {
10997   int rec = stack->ninsn - 1;
10998   assert (!istack_empty (stack));
10999   stack->ninsn--;
11000   memset (&stack->insn[rec], 0, sizeof (TInsn));
11001 }
11002
11003 \f
11004 /* TInsn functions.  */
11005
11006 void
11007 tinsn_init (TInsn *dst)
11008 {
11009   memset (dst, 0, sizeof (TInsn));
11010 }
11011
11012
11013 /* Get the ``num''th token of the TInsn.
11014    It is illegal to call this if num > insn->ntoks.  */
11015
11016 expressionS *
11017 tinsn_get_tok (TInsn *insn, int num)
11018 {
11019   assert (num < insn->ntok);
11020   return &insn->tok[num];
11021 }
11022
11023
11024 /* Return TRUE if ANY of the operands in the insn are symbolic.  */
11025
11026 static bfd_boolean
11027 tinsn_has_symbolic_operands (const TInsn *insn)
11028 {
11029   int i;
11030   int n = insn->ntok;
11031
11032   assert (insn->insn_type == ITYPE_INSN);
11033
11034   for (i = 0; i < n; ++i)
11035     {
11036       switch (insn->tok[i].X_op)
11037         {
11038         case O_register:
11039         case O_constant:
11040           break;
11041         default:
11042           return TRUE;
11043         }
11044     }
11045   return FALSE;
11046 }
11047
11048
11049 bfd_boolean
11050 tinsn_has_invalid_symbolic_operands (const TInsn *insn)
11051 {
11052   xtensa_isa isa = xtensa_default_isa;
11053   int i;
11054   int n = insn->ntok;
11055
11056   assert (insn->insn_type == ITYPE_INSN);
11057
11058   for (i = 0; i < n; ++i)
11059     {
11060       switch (insn->tok[i].X_op)
11061         {
11062         case O_register:
11063         case O_constant:
11064           break;
11065         case O_big:
11066         case O_illegal:
11067         case O_absent:
11068           /* Errors for these types are caught later.  */
11069           break;
11070         case O_hi16:
11071         case O_lo16:
11072         default:
11073           /* Symbolic immediates are only allowed on the last immediate
11074              operand.  At this time, CONST16 is the only opcode where we
11075              support non-PC-relative relocations.  (It isn't necessary
11076              to complain about non-PC-relative relocations here, but
11077              otherwise, no error is reported until the relocations are
11078              generated, and the assembler won't get that far if there
11079              are any other errors.  It's nice to see all the problems
11080              at once.)  */
11081           if (i != get_relaxable_immed (insn->opcode)
11082               || (xtensa_operand_is_PCrelative (isa, insn->opcode, i) != 1
11083                   && insn->opcode != xtensa_const16_opcode))
11084             {
11085               as_bad (_("invalid symbolic operand %d on '%s'"),
11086                       i, xtensa_opcode_name (isa, insn->opcode));
11087               return TRUE;
11088             }
11089         }
11090     }
11091   return FALSE;
11092 }
11093
11094
11095 /* For assembly code with complex expressions (e.g. subtraction),
11096    we have to build them in the literal pool so that
11097    their results are calculated correctly after relaxation.
11098    The relaxation only handles expressions that
11099    boil down to SYMBOL + OFFSET.  */
11100
11101 static bfd_boolean
11102 tinsn_has_complex_operands (const TInsn *insn)
11103 {
11104   int i;
11105   int n = insn->ntok;
11106   assert (insn->insn_type == ITYPE_INSN);
11107   for (i = 0; i < n; ++i)
11108     {
11109       switch (insn->tok[i].X_op)
11110         {
11111         case O_register:
11112         case O_constant:
11113         case O_symbol:
11114         case O_lo16:
11115         case O_hi16:
11116           break;
11117         default:
11118           return TRUE;
11119         }
11120     }
11121   return FALSE;
11122 }
11123
11124
11125 /* Convert the constant operands in the tinsn to insnbuf.
11126    Return TRUE if there is a symbol in the immediate field.
11127
11128    Before this is called,
11129    1) the number of operands are correct
11130    2) the tinsn is a ITYPE_INSN
11131    3) ONLY the relaxable_ is built
11132    4) All operands are O_constant, O_symbol.  All constants fit
11133    The return value tells whether there are any remaining O_symbols.  */
11134
11135 static bfd_boolean
11136 tinsn_to_insnbuf (TInsn *tinsn, xtensa_insnbuf insnbuf)
11137 {
11138   static xtensa_insnbuf slotbuf = 0;
11139   xtensa_isa isa = xtensa_default_isa;
11140   xtensa_opcode opcode = tinsn->opcode;
11141   xtensa_format fmt = xg_get_single_format (opcode);
11142   bfd_boolean has_fixup = FALSE;
11143   int noperands = xtensa_opcode_num_operands (isa, opcode);
11144   int i;
11145   uint32 opnd_value;
11146   char *file_name;
11147   unsigned line;
11148
11149   if (!slotbuf)
11150     slotbuf = xtensa_insnbuf_alloc (isa);
11151
11152   assert (tinsn->insn_type == ITYPE_INSN);
11153   if (noperands != tinsn->ntok)
11154     as_fatal (_("operand number mismatch"));
11155
11156   if (xtensa_opcode_encode (isa, fmt, 0, slotbuf, opcode))
11157     as_fatal (_("cannot encode opcode"));
11158
11159   for (i = 0; i < noperands; ++i)
11160     {
11161       expressionS *expr = &tinsn->tok[i];
11162       switch (expr->X_op)
11163         {
11164         case O_register:
11165           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11166             break;
11167           /* The register number has already been checked in
11168              expression_maybe_register, so we don't need to check here.  */
11169           opnd_value = expr->X_add_number;
11170           (void) xtensa_operand_encode (isa, opcode, i, &opnd_value);
11171           xtensa_operand_set_field (isa, opcode, i, fmt, 0,
11172                                     slotbuf, opnd_value);
11173           break;
11174
11175         case O_constant:
11176           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11177             break;
11178           as_where (&file_name, &line);
11179           /* It is a constant and we called this function,
11180              then we have to try to fit it.  */
11181           xtensa_insnbuf_set_operand (slotbuf, fmt, 0, opcode, i,
11182                                       expr->X_add_number, file_name, line);
11183           break;
11184
11185         default:
11186           has_fixup = TRUE;
11187           break;
11188         }
11189     }
11190
11191   xtensa_format_encode (isa, fmt, insnbuf);
11192   xtensa_format_set_slot (isa, fmt, 0, insnbuf, slotbuf);
11193
11194   return has_fixup;
11195 }
11196
11197
11198 /* Convert the constant operands in the tinsn to slotbuf.
11199    Return TRUE if there is a symbol in the immediate field.
11200    (Eventually this should replace tinsn_to_insnbuf.)  */
11201
11202 /* Before this is called,
11203    1) the number of operands are correct
11204    2) the tinsn is a ITYPE_INSN
11205    3) ONLY the relaxable_ is built
11206    4) All operands are
11207        O_constant, O_symbol
11208       All constants fit
11209
11210    The return value tells whether there are any remaining O_symbols.  */
11211
11212 static bfd_boolean
11213 tinsn_to_slotbuf (xtensa_format fmt,
11214                   int slot,
11215                   TInsn *tinsn,
11216                   xtensa_insnbuf slotbuf)
11217 {
11218   xtensa_isa isa = xtensa_default_isa;
11219   xtensa_opcode opcode = tinsn->opcode;
11220   bfd_boolean has_fixup = FALSE;
11221   int noperands = xtensa_opcode_num_operands (isa, opcode);
11222   int i;
11223
11224   *((int *) &slotbuf[0]) = 0;
11225   *((int *) &slotbuf[1]) = 0;
11226   assert (tinsn->insn_type == ITYPE_INSN);
11227   if (noperands != tinsn->ntok)
11228     as_fatal (_("operand number mismatch"));
11229
11230   if (xtensa_opcode_encode (isa, fmt, slot, slotbuf, opcode))
11231     {
11232       as_bad (_("cannot encode opcode \"%s\" in the given format \"%s\""),
11233               xtensa_opcode_name (isa, opcode), xtensa_format_name (isa, fmt));
11234       return FALSE;
11235     }
11236
11237   for (i = 0; i < noperands; i++)
11238     {
11239       expressionS *expr = &tinsn->tok[i];
11240       int rc;
11241       unsigned line;
11242       char *file_name;
11243       uint32 opnd_value;
11244
11245       switch (expr->X_op)
11246         {
11247         case O_register:
11248           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11249             break;
11250           /* The register number has already been checked in
11251              expression_maybe_register, so we don't need to check here.  */
11252           opnd_value = expr->X_add_number;
11253           (void) xtensa_operand_encode (isa, opcode, i, &opnd_value);
11254           rc = xtensa_operand_set_field (isa, opcode, i, fmt, slot, slotbuf,
11255                                          opnd_value);
11256           if (rc != 0)
11257             as_warn (_("xtensa-isa failure: %s"), xtensa_isa_error_msg (isa));
11258           break;
11259
11260         case O_constant:
11261           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11262             break;
11263           as_where (&file_name, &line);
11264           /* It is a constant and we called this function
11265              then we have to try to fit it.  */
11266           xtensa_insnbuf_set_operand (slotbuf, fmt, slot, opcode, i,
11267                                       expr->X_add_number, file_name, line);
11268           break;
11269
11270         default:
11271           has_fixup = TRUE;
11272           break;
11273         }
11274     }
11275
11276   return has_fixup;
11277 }
11278
11279
11280 /* Check the instruction arguments.  Return TRUE on failure.  */
11281
11282 static bfd_boolean
11283 tinsn_check_arguments (const TInsn *insn)
11284 {
11285   xtensa_isa isa = xtensa_default_isa;
11286   xtensa_opcode opcode = insn->opcode;
11287
11288   if (opcode == XTENSA_UNDEFINED)
11289     {
11290       as_bad (_("invalid opcode"));
11291       return TRUE;
11292     }
11293
11294   if (xtensa_opcode_num_operands (isa, opcode) > insn->ntok)
11295     {
11296       as_bad (_("too few operands"));
11297       return TRUE;
11298     }
11299
11300   if (xtensa_opcode_num_operands (isa, opcode) < insn->ntok)
11301     {
11302       as_bad (_("too many operands"));
11303       return TRUE;
11304     }
11305   return FALSE;
11306 }
11307
11308
11309 /* Load an instruction from its encoded form.  */
11310
11311 static void
11312 tinsn_from_chars (TInsn *tinsn, char *f, int slot)
11313 {
11314   vliw_insn vinsn;
11315
11316   xg_init_vinsn (&vinsn);
11317   vinsn_from_chars (&vinsn, f);
11318
11319   *tinsn = vinsn.slots[slot];
11320   xg_free_vinsn (&vinsn);
11321 }
11322
11323
11324 static void
11325 tinsn_from_insnbuf (TInsn *tinsn,
11326                     xtensa_insnbuf slotbuf,
11327                     xtensa_format fmt,
11328                     int slot)
11329 {
11330   int i;
11331   xtensa_isa isa = xtensa_default_isa;
11332
11333   /* Find the immed.  */
11334   tinsn_init (tinsn);
11335   tinsn->insn_type = ITYPE_INSN;
11336   tinsn->is_specific_opcode = FALSE;    /* must not be specific */
11337   tinsn->opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
11338   tinsn->ntok = xtensa_opcode_num_operands (isa, tinsn->opcode);
11339   for (i = 0; i < tinsn->ntok; i++)
11340     {
11341       set_expr_const (&tinsn->tok[i],
11342                       xtensa_insnbuf_get_operand (slotbuf, fmt, slot,
11343                                                   tinsn->opcode, i));
11344     }
11345 }
11346
11347
11348 /* Read the value of the relaxable immed from the fr_symbol and fr_offset.  */
11349
11350 static void
11351 tinsn_immed_from_frag (TInsn *tinsn, fragS *fragP, int slot)
11352 {
11353   xtensa_opcode opcode = tinsn->opcode;
11354   int opnum;
11355
11356   if (fragP->tc_frag_data.slot_symbols[slot])
11357     {
11358       opnum = get_relaxable_immed (opcode);
11359       assert (opnum >= 0);
11360       if (fragP->tc_frag_data.slot_sub_symbols[slot])
11361         {
11362           set_expr_symbol_offset_diff
11363             (&tinsn->tok[opnum],
11364              fragP->tc_frag_data.slot_symbols[slot],
11365              fragP->tc_frag_data.slot_sub_symbols[slot],
11366              fragP->tc_frag_data.slot_offsets[slot]);
11367         }
11368       else
11369         {
11370           set_expr_symbol_offset
11371             (&tinsn->tok[opnum],
11372              fragP->tc_frag_data.slot_symbols[slot],
11373              fragP->tc_frag_data.slot_offsets[slot]);
11374         }
11375     }
11376 }
11377
11378
11379 static int
11380 get_num_stack_text_bytes (IStack *istack)
11381 {
11382   int i;
11383   int text_bytes = 0;
11384
11385   for (i = 0; i < istack->ninsn; i++)
11386     {
11387       TInsn *tinsn = &istack->insn[i];
11388       if (tinsn->insn_type == ITYPE_INSN)
11389         text_bytes += xg_get_single_size (tinsn->opcode);
11390     }
11391   return text_bytes;
11392 }
11393
11394
11395 static int
11396 get_num_stack_literal_bytes (IStack *istack)
11397 {
11398   int i;
11399   int lit_bytes = 0;
11400
11401   for (i = 0; i < istack->ninsn; i++)
11402     {
11403       TInsn *tinsn = &istack->insn[i];
11404       if (tinsn->insn_type == ITYPE_LITERAL && tinsn->ntok == 1)
11405         lit_bytes += 4;
11406     }
11407   return lit_bytes;
11408 }
11409
11410 \f
11411 /* vliw_insn functions.  */
11412
11413 static void
11414 xg_init_vinsn (vliw_insn *v)
11415 {
11416   int i;
11417   xtensa_isa isa = xtensa_default_isa;
11418
11419   xg_clear_vinsn (v);
11420
11421   v->insnbuf = xtensa_insnbuf_alloc (isa);
11422   if (v->insnbuf == NULL)
11423     as_fatal (_("out of memory"));
11424
11425   for (i = 0; i < MAX_SLOTS; i++)
11426     {
11427       tinsn_init (&v->slots[i]);
11428       v->slots[i].opcode = XTENSA_UNDEFINED;
11429       v->slotbuf[i] = xtensa_insnbuf_alloc (isa);
11430       if (v->slotbuf[i] == NULL)
11431         as_fatal (_("out of memory"));
11432     }
11433 }
11434
11435
11436 static void
11437 xg_clear_vinsn (vliw_insn *v)
11438 {
11439   int i;
11440   v->format = XTENSA_UNDEFINED;
11441   v->num_slots = 0;
11442   v->inside_bundle = FALSE;
11443
11444   if (xt_saved_debug_type != DEBUG_NONE)
11445     debug_type = xt_saved_debug_type;
11446
11447   for (i = 0; i < MAX_SLOTS; i++)
11448     {
11449       memset (&v->slots[i], 0, sizeof (TInsn));
11450       v->slots[i].opcode = XTENSA_UNDEFINED;
11451     }
11452 }
11453
11454
11455 static bfd_boolean
11456 vinsn_has_specific_opcodes (vliw_insn *v)
11457 {
11458   int i;
11459
11460   for (i = 0; i < v->num_slots; i++)
11461     {
11462       if (v->slots[i].is_specific_opcode)
11463         return TRUE;
11464     }
11465   return FALSE;
11466 }
11467
11468
11469 static void
11470 xg_free_vinsn (vliw_insn *v)
11471 {
11472   int i;
11473   xtensa_insnbuf_free (xtensa_default_isa, v->insnbuf);
11474   for (i = 0; i < MAX_SLOTS; i++)
11475     xtensa_insnbuf_free (xtensa_default_isa, v->slotbuf[i]);
11476 }
11477
11478
11479 /* Before this is called, we should have
11480    filled out the following fields:
11481
11482    1) the number of operands for each opcode are correct
11483    2) the tinsn in the slots are ITYPE_INSN
11484    3) ONLY the relaxable_ is built
11485    4) All operands are
11486        O_constant, O_symbol
11487       All constants fit
11488
11489    The return value tells whether there are any remaining O_symbols.  */
11490
11491 static bfd_boolean
11492 vinsn_to_insnbuf (vliw_insn *vinsn,
11493                   char *frag_offset,
11494                   fragS *fragP,
11495                   bfd_boolean record_fixup)
11496 {
11497   xtensa_isa isa = xtensa_default_isa;
11498   xtensa_format fmt = vinsn->format;
11499   xtensa_insnbuf insnbuf = vinsn->insnbuf;
11500   int slot;
11501   bfd_boolean has_fixup = FALSE;
11502
11503   xtensa_format_encode (isa, fmt, insnbuf);
11504
11505   for (slot = 0; slot < vinsn->num_slots; slot++)
11506     {
11507       TInsn *tinsn = &vinsn->slots[slot];
11508       bfd_boolean tinsn_has_fixup =
11509         tinsn_to_slotbuf (vinsn->format, slot, tinsn,
11510                           vinsn->slotbuf[slot]);
11511
11512       xtensa_format_set_slot (isa, fmt, slot,
11513                               insnbuf, vinsn->slotbuf[slot]);
11514       /* tinsn_has_fixup tracks if there is a fixup at all.
11515          record_fixup controls globally.  I.E., we use this
11516          function from several places, some of which are after
11517          fixups have already been recorded.  Finally,
11518          tinsn->record_fixup controls based on the individual ops,
11519          which may or may not need it based on the relaxation
11520          requirements.  */
11521       if (tinsn_has_fixup && record_fixup)
11522         {
11523           int i;
11524           xtensa_opcode opcode = tinsn->opcode;
11525           int noperands = xtensa_opcode_num_operands (isa, opcode);
11526           has_fixup = TRUE;
11527
11528           for (i = 0; i < noperands; i++)
11529             {
11530               expressionS* expr = &tinsn->tok[i];
11531               switch (expr->X_op)
11532                 {
11533                 case O_symbol:
11534                 case O_lo16:
11535                 case O_hi16:
11536                   if (get_relaxable_immed (opcode) == i)
11537                     {
11538                       if (tinsn->record_fix || expr->X_op != O_symbol)
11539                         {
11540                           if (!xg_add_opcode_fix
11541                               (tinsn, i, fmt, slot, expr, fragP,
11542                                frag_offset - fragP->fr_literal))
11543                             as_bad (_("instruction with constant operands does not fit"));
11544                         }
11545                       else
11546                         {
11547                           tinsn->symbol = expr->X_add_symbol;
11548                           tinsn->offset = expr->X_add_number;
11549                         }
11550                     }
11551                   else
11552                     as_bad (_("invalid operand %d on '%s'"),
11553                             i, xtensa_opcode_name (isa, opcode));
11554                   break;
11555
11556                 case O_constant:
11557                 case O_register:
11558                   break;
11559
11560                 case O_subtract:
11561                   if (get_relaxable_immed (opcode) == i)
11562                     {
11563                       if (tinsn->record_fix)
11564                           as_bad (_("invalid subtract operand"));
11565                       else
11566                         {
11567                           tinsn->symbol = expr->X_add_symbol;
11568                           tinsn->sub_symbol = expr->X_op_symbol;
11569                           tinsn->offset = expr->X_add_number;
11570                         }
11571                     }
11572                   else
11573                     as_bad (_("invalid operand %d on '%s'"),
11574                             i, xtensa_opcode_name (isa, opcode));
11575                   break;
11576
11577                 default:
11578                   as_bad (_("invalid expression for operand %d on '%s'"),
11579                           i, xtensa_opcode_name (isa, opcode));
11580                   break;
11581                 }
11582             }
11583         }
11584     }
11585
11586   return has_fixup;
11587 }
11588
11589
11590 static void
11591 vinsn_from_chars (vliw_insn *vinsn, char *f)
11592 {
11593   static xtensa_insnbuf insnbuf = NULL;
11594   static xtensa_insnbuf slotbuf = NULL;
11595   int i;
11596   xtensa_format fmt;
11597   xtensa_isa isa = xtensa_default_isa;
11598
11599   if (!insnbuf)
11600     {
11601       insnbuf = xtensa_insnbuf_alloc (isa);
11602       slotbuf = xtensa_insnbuf_alloc (isa);
11603     }
11604
11605   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) f, 0);
11606   fmt = xtensa_format_decode (isa, insnbuf);
11607   if (fmt == XTENSA_UNDEFINED)
11608     as_fatal (_("cannot decode instruction format"));
11609   vinsn->format = fmt;
11610   vinsn->num_slots = xtensa_format_num_slots (isa, fmt);
11611
11612   for (i = 0; i < vinsn->num_slots; i++)
11613     {
11614       TInsn *tinsn = &vinsn->slots[i];
11615       xtensa_format_get_slot (isa, fmt, i, insnbuf, slotbuf);
11616       tinsn_from_insnbuf (tinsn, slotbuf, fmt, i);
11617     }
11618 }
11619
11620 \f
11621 /* Expression utilities.  */
11622
11623 /* Return TRUE if the expression is an integer constant.  */
11624
11625 bfd_boolean
11626 expr_is_const (const expressionS *s)
11627 {
11628   return (s->X_op == O_constant);
11629 }
11630
11631
11632 /* Get the expression constant.
11633    Calling this is illegal if expr_is_const () returns TRUE.  */
11634
11635 offsetT
11636 get_expr_const (const expressionS *s)
11637 {
11638   assert (expr_is_const (s));
11639   return s->X_add_number;
11640 }
11641
11642
11643 /* Set the expression to a constant value.  */
11644
11645 void
11646 set_expr_const (expressionS *s, offsetT val)
11647 {
11648   s->X_op = O_constant;
11649   s->X_add_number = val;
11650   s->X_add_symbol = NULL;
11651   s->X_op_symbol = NULL;
11652 }
11653
11654
11655 bfd_boolean
11656 expr_is_register (const expressionS *s)
11657 {
11658   return (s->X_op == O_register);
11659 }
11660
11661
11662 /* Get the expression constant.
11663    Calling this is illegal if expr_is_const () returns TRUE.  */
11664
11665 offsetT
11666 get_expr_register (const expressionS *s)
11667 {
11668   assert (expr_is_register (s));
11669   return s->X_add_number;
11670 }
11671
11672
11673 /* Set the expression to a symbol + constant offset.  */
11674
11675 void
11676 set_expr_symbol_offset (expressionS *s, symbolS *sym, offsetT offset)
11677 {
11678   s->X_op = O_symbol;
11679   s->X_add_symbol = sym;
11680   s->X_op_symbol = NULL;        /* unused */
11681   s->X_add_number = offset;
11682 }
11683
11684
11685 /* Set the expression to symbol - minus_sym + offset.  */
11686
11687 static void
11688 set_expr_symbol_offset_diff (expressionS *s,
11689                              symbolS *sym,
11690                              symbolS *minus_sym,
11691                              offsetT offset)
11692 {
11693   s->X_op = O_subtract;
11694   s->X_add_symbol = sym;
11695   s->X_op_symbol = minus_sym;   /* unused */
11696   s->X_add_number = offset;
11697 }
11698
11699
11700 /* Return TRUE if the two expressions are equal.  */
11701
11702 bfd_boolean
11703 expr_is_equal (expressionS *s1, expressionS *s2)
11704 {
11705   if (s1->X_op != s2->X_op)
11706     return FALSE;
11707   if (s1->X_add_symbol != s2->X_add_symbol)
11708     return FALSE;
11709   if (s1->X_op_symbol != s2->X_op_symbol)
11710     return FALSE;
11711   if (s1->X_add_number != s2->X_add_number)
11712     return FALSE;
11713   return TRUE;
11714 }
11715
11716
11717 static void
11718 copy_expr (expressionS *dst, const expressionS *src)
11719 {
11720   memcpy (dst, src, sizeof (expressionS));
11721 }
11722
11723 \f
11724 /* Support for the "--rename-section" option.  */
11725
11726 struct rename_section_struct
11727 {
11728   char *old_name;
11729   char *new_name;
11730   struct rename_section_struct *next;
11731 };
11732
11733 static struct rename_section_struct *section_rename;
11734
11735
11736 /* Parse the string "oldname=new_name(:oldname2=new_name2)*" and add
11737    entries to the section_rename list.  Note: Specifying multiple
11738    renamings separated by colons is not documented and is retained only
11739    for backward compatibility.  */
11740
11741 static void
11742 build_section_rename (const char *arg)
11743 {
11744   struct rename_section_struct *r;
11745   char *this_arg = NULL;
11746   char *next_arg = NULL;
11747
11748   for (this_arg = xstrdup (arg); this_arg != NULL; this_arg = next_arg)
11749     {
11750       char *old_name, *new_name;
11751
11752       if (this_arg)
11753         {
11754           next_arg = strchr (this_arg, ':');
11755           if (next_arg)
11756             {
11757               *next_arg = '\0';
11758               next_arg++;
11759             }
11760         }
11761
11762       old_name = this_arg;
11763       new_name = strchr (this_arg, '=');
11764
11765       if (*old_name == '\0')
11766         {
11767           as_warn (_("ignoring extra '-rename-section' delimiter ':'"));
11768           continue;
11769         }
11770       if (!new_name || new_name[1] == '\0')
11771         {
11772           as_warn (_("ignoring invalid '-rename-section' specification: '%s'"),
11773                    old_name);
11774           continue;
11775         }
11776       *new_name = '\0';
11777       new_name++;
11778
11779       /* Check for invalid section renaming.  */
11780       for (r = section_rename; r != NULL; r = r->next)
11781         {
11782           if (strcmp (r->old_name, old_name) == 0)
11783             as_bad (_("section %s renamed multiple times"), old_name);
11784           if (strcmp (r->new_name, new_name) == 0)
11785             as_bad (_("multiple sections remapped to output section %s"),
11786                     new_name);
11787         }
11788
11789       /* Now add it.  */
11790       r = (struct rename_section_struct *)
11791         xmalloc (sizeof (struct rename_section_struct));
11792       r->old_name = xstrdup (old_name);
11793       r->new_name = xstrdup (new_name);
11794       r->next = section_rename;
11795       section_rename = r;
11796     }
11797 }
11798
11799
11800 char *
11801 xtensa_section_rename (char *name)
11802 {
11803   struct rename_section_struct *r = section_rename;
11804
11805   for (r = section_rename; r != NULL; r = r->next)
11806     {
11807       if (strcmp (r->old_name, name) == 0)
11808         return r->new_name;
11809     }
11810
11811   return name;
11812 }