* config/tc-mips.c (ISA_SUPPORTS_MCU_ASE): Also set if microMIPS
[external/binutils.git] / gas / config / tc-mips.c
1 /* tc-mips.c -- assemble code for a MIPS chip.
2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3    2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5    Contributed by the OSF and Ralph Campbell.
6    Written by Keith Knowles and Ralph Campbell, working independently.
7    Modified for ECOFF and R4000 support by Ian Lance Taylor of Cygnus
8    Support.
9
10    This file is part of GAS.
11
12    GAS is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 3, or (at your option)
15    any later version.
16
17    GAS is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with GAS; see the file COPYING.  If not, write to the Free
24    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25    02110-1301, USA.  */
26
27 #include "as.h"
28 #include "config.h"
29 #include "subsegs.h"
30 #include "safe-ctype.h"
31
32 #include "opcode/mips.h"
33 #include "itbl-ops.h"
34 #include "dwarf2dbg.h"
35 #include "dw2gencfi.h"
36
37 #ifdef DEBUG
38 #define DBG(x) printf x
39 #else
40 #define DBG(x)
41 #endif
42
43 #ifdef OBJ_MAYBE_ELF
44 /* Clean up namespace so we can include obj-elf.h too.  */
45 static int mips_output_flavor (void);
46 static int mips_output_flavor (void) { return OUTPUT_FLAVOR; }
47 #undef OBJ_PROCESS_STAB
48 #undef OUTPUT_FLAVOR
49 #undef S_GET_ALIGN
50 #undef S_GET_SIZE
51 #undef S_SET_ALIGN
52 #undef S_SET_SIZE
53 #undef obj_frob_file
54 #undef obj_frob_file_after_relocs
55 #undef obj_frob_symbol
56 #undef obj_pop_insert
57 #undef obj_sec_sym_ok_for_reloc
58 #undef OBJ_COPY_SYMBOL_ATTRIBUTES
59
60 #include "obj-elf.h"
61 /* Fix any of them that we actually care about.  */
62 #undef OUTPUT_FLAVOR
63 #define OUTPUT_FLAVOR mips_output_flavor()
64 #endif
65
66 #if defined (OBJ_ELF)
67 #include "elf/mips.h"
68 #endif
69
70 #ifndef ECOFF_DEBUGGING
71 #define NO_ECOFF_DEBUGGING
72 #define ECOFF_DEBUGGING 0
73 #endif
74
75 int mips_flag_mdebug = -1;
76
77 /* Control generation of .pdr sections.  Off by default on IRIX: the native
78    linker doesn't know about and discards them, but relocations against them
79    remain, leading to rld crashes.  */
80 #ifdef TE_IRIX
81 int mips_flag_pdr = FALSE;
82 #else
83 int mips_flag_pdr = TRUE;
84 #endif
85
86 #include "ecoff.h"
87
88 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
89 static char *mips_regmask_frag;
90 #endif
91
92 #define ZERO 0
93 #define ATREG 1
94 #define S0  16
95 #define S7  23
96 #define TREG 24
97 #define PIC_CALL_REG 25
98 #define KT0 26
99 #define KT1 27
100 #define GP  28
101 #define SP  29
102 #define FP  30
103 #define RA  31
104
105 #define ILLEGAL_REG (32)
106
107 #define AT  mips_opts.at
108
109 /* Allow override of standard little-endian ECOFF format.  */
110
111 #ifndef ECOFF_LITTLE_FORMAT
112 #define ECOFF_LITTLE_FORMAT "ecoff-littlemips"
113 #endif
114
115 extern int target_big_endian;
116
117 /* The name of the readonly data section.  */
118 #define RDATA_SECTION_NAME (OUTPUT_FLAVOR == bfd_target_ecoff_flavour \
119                             ? ".rdata" \
120                             : OUTPUT_FLAVOR == bfd_target_coff_flavour \
121                             ? ".rdata" \
122                             : OUTPUT_FLAVOR == bfd_target_elf_flavour \
123                             ? ".rodata" \
124                             : (abort (), ""))
125
126 /* Ways in which an instruction can be "appended" to the output.  */
127 enum append_method {
128   /* Just add it normally.  */
129   APPEND_ADD,
130
131   /* Add it normally and then add a nop.  */
132   APPEND_ADD_WITH_NOP,
133
134   /* Turn an instruction with a delay slot into a "compact" version.  */
135   APPEND_ADD_COMPACT,
136
137   /* Insert the instruction before the last one.  */
138   APPEND_SWAP
139 };
140
141 /* Information about an instruction, including its format, operands
142    and fixups.  */
143 struct mips_cl_insn
144 {
145   /* The opcode's entry in mips_opcodes or mips16_opcodes.  */
146   const struct mips_opcode *insn_mo;
147
148   /* True if this is a mips16 instruction and if we want the extended
149      form of INSN_MO.  */
150   bfd_boolean use_extend;
151
152   /* The 16-bit extension instruction to use when USE_EXTEND is true.  */
153   unsigned short extend;
154
155   /* The 16-bit or 32-bit bitstring of the instruction itself.  This is
156      a copy of INSN_MO->match with the operands filled in.  */
157   unsigned long insn_opcode;
158
159   /* The frag that contains the instruction.  */
160   struct frag *frag;
161
162   /* The offset into FRAG of the first instruction byte.  */
163   long where;
164
165   /* The relocs associated with the instruction, if any.  */
166   fixS *fixp[3];
167
168   /* True if this entry cannot be moved from its current position.  */
169   unsigned int fixed_p : 1;
170
171   /* True if this instruction occurred in a .set noreorder block.  */
172   unsigned int noreorder_p : 1;
173
174   /* True for mips16 instructions that jump to an absolute address.  */
175   unsigned int mips16_absolute_jump_p : 1;
176
177   /* True if this instruction is complete.  */
178   unsigned int complete_p : 1;
179 };
180
181 /* The ABI to use.  */
182 enum mips_abi_level
183 {
184   NO_ABI = 0,
185   O32_ABI,
186   O64_ABI,
187   N32_ABI,
188   N64_ABI,
189   EABI_ABI
190 };
191
192 /* MIPS ABI we are using for this output file.  */
193 static enum mips_abi_level mips_abi = NO_ABI;
194
195 /* Whether or not we have code that can call pic code.  */
196 int mips_abicalls = FALSE;
197
198 /* Whether or not we have code which can be put into a shared
199    library.  */
200 static bfd_boolean mips_in_shared = TRUE;
201
202 /* This is the set of options which may be modified by the .set
203    pseudo-op.  We use a struct so that .set push and .set pop are more
204    reliable.  */
205
206 struct mips_set_options
207 {
208   /* MIPS ISA (Instruction Set Architecture) level.  This is set to -1
209      if it has not been initialized.  Changed by `.set mipsN', and the
210      -mipsN command line option, and the default CPU.  */
211   int isa;
212   /* Enabled Application Specific Extensions (ASEs).  These are set to -1
213      if they have not been initialized.  Changed by `.set <asename>', by
214      command line options, and based on the default architecture.  */
215   int ase_mips3d;
216   int ase_mdmx;
217   int ase_smartmips;
218   int ase_dsp;
219   int ase_dspr2;
220   int ase_mt;
221   int ase_mcu;
222   /* Whether we are assembling for the mips16 processor.  0 if we are
223      not, 1 if we are, and -1 if the value has not been initialized.
224      Changed by `.set mips16' and `.set nomips16', and the -mips16 and
225      -nomips16 command line options, and the default CPU.  */
226   int mips16;
227   /* Whether we are assembling for the mipsMIPS ASE.  0 if we are not,
228      1 if we are, and -1 if the value has not been initialized.  Changed
229      by `.set micromips' and `.set nomicromips', and the -mmicromips
230      and -mno-micromips command line options, and the default CPU.  */
231   int micromips;
232   /* Non-zero if we should not reorder instructions.  Changed by `.set
233      reorder' and `.set noreorder'.  */
234   int noreorder;
235   /* Non-zero if we should not permit the register designated "assembler
236      temporary" to be used in instructions.  The value is the register
237      number, normally $at ($1).  Changed by `.set at=REG', `.set noat'
238      (same as `.set at=$0') and `.set at' (same as `.set at=$1').  */
239   unsigned int at;
240   /* Non-zero if we should warn when a macro instruction expands into
241      more than one machine instruction.  Changed by `.set nomacro' and
242      `.set macro'.  */
243   int warn_about_macros;
244   /* Non-zero if we should not move instructions.  Changed by `.set
245      move', `.set volatile', `.set nomove', and `.set novolatile'.  */
246   int nomove;
247   /* Non-zero if we should not optimize branches by moving the target
248      of the branch into the delay slot.  Actually, we don't perform
249      this optimization anyhow.  Changed by `.set bopt' and `.set
250      nobopt'.  */
251   int nobopt;
252   /* Non-zero if we should not autoextend mips16 instructions.
253      Changed by `.set autoextend' and `.set noautoextend'.  */
254   int noautoextend;
255   /* Restrict general purpose registers and floating point registers
256      to 32 bit.  This is initially determined when -mgp32 or -mfp32
257      is passed but can changed if the assembler code uses .set mipsN.  */
258   int gp32;
259   int fp32;
260   /* MIPS architecture (CPU) type.  Changed by .set arch=FOO, the -march
261      command line option, and the default CPU.  */
262   int arch;
263   /* True if ".set sym32" is in effect.  */
264   bfd_boolean sym32;
265   /* True if floating-point operations are not allowed.  Changed by .set
266      softfloat or .set hardfloat, by command line options -msoft-float or
267      -mhard-float.  The default is false.  */
268   bfd_boolean soft_float;
269
270   /* True if only single-precision floating-point operations are allowed.
271      Changed by .set singlefloat or .set doublefloat, command-line options
272      -msingle-float or -mdouble-float.  The default is false.  */
273   bfd_boolean single_float;
274 };
275
276 /* This is the struct we use to hold the current set of options.  Note
277    that we must set the isa field to ISA_UNKNOWN and the ASE fields to
278    -1 to indicate that they have not been initialized.  */
279
280 /* True if -mgp32 was passed.  */
281 static int file_mips_gp32 = -1;
282
283 /* True if -mfp32 was passed.  */
284 static int file_mips_fp32 = -1;
285
286 /* 1 if -msoft-float, 0 if -mhard-float.  The default is 0.  */
287 static int file_mips_soft_float = 0;
288
289 /* 1 if -msingle-float, 0 if -mdouble-float.  The default is 0.   */
290 static int file_mips_single_float = 0;
291
292 static struct mips_set_options mips_opts =
293 {
294   /* isa */ ISA_UNKNOWN, /* ase_mips3d */ -1, /* ase_mdmx */ -1,
295   /* ase_smartmips */ 0, /* ase_dsp */ -1, /* ase_dspr2 */ -1, /* ase_mt */ -1,
296   /* ase_mcu */ -1, /* mips16 */ -1, /* micromips */ -1, /* noreorder */ 0,
297   /* at */ ATREG, /* warn_about_macros */ 0, /* nomove */ 0, /* nobopt */ 0,
298   /* noautoextend */ 0, /* gp32 */ 0, /* fp32 */ 0, /* arch */ CPU_UNKNOWN,
299   /* sym32 */ FALSE, /* soft_float */ FALSE, /* single_float */ FALSE
300 };
301
302 /* These variables are filled in with the masks of registers used.
303    The object format code reads them and puts them in the appropriate
304    place.  */
305 unsigned long mips_gprmask;
306 unsigned long mips_cprmask[4];
307
308 /* MIPS ISA we are using for this output file.  */
309 static int file_mips_isa = ISA_UNKNOWN;
310
311 /* True if any MIPS16 code was produced.  */
312 static int file_ase_mips16;
313
314 #define ISA_SUPPORTS_MIPS16E (mips_opts.isa == ISA_MIPS32               \
315                               || mips_opts.isa == ISA_MIPS32R2          \
316                               || mips_opts.isa == ISA_MIPS64            \
317                               || mips_opts.isa == ISA_MIPS64R2)
318
319 /* True if any microMIPS code was produced.  */
320 static int file_ase_micromips;
321
322 /* True if we want to create R_MIPS_JALR for jalr $25.  */
323 #ifdef TE_IRIX
324 #define MIPS_JALR_HINT_P(EXPR) HAVE_NEWABI
325 #else
326 /* As a GNU extension, we use R_MIPS_JALR for o32 too.  However,
327    because there's no place for any addend, the only acceptable
328    expression is a bare symbol.  */
329 #define MIPS_JALR_HINT_P(EXPR) \
330   (!HAVE_IN_PLACE_ADDENDS \
331    || ((EXPR)->X_op == O_symbol && (EXPR)->X_add_number == 0))
332 #endif
333
334 /* True if -mips3d was passed or implied by arguments passed on the
335    command line (e.g., by -march).  */
336 static int file_ase_mips3d;
337
338 /* True if -mdmx was passed or implied by arguments passed on the
339    command line (e.g., by -march).  */
340 static int file_ase_mdmx;
341
342 /* True if -msmartmips was passed or implied by arguments passed on the
343    command line (e.g., by -march).  */
344 static int file_ase_smartmips;
345
346 #define ISA_SUPPORTS_SMARTMIPS (mips_opts.isa == ISA_MIPS32             \
347                                 || mips_opts.isa == ISA_MIPS32R2)
348
349 /* True if -mdsp was passed or implied by arguments passed on the
350    command line (e.g., by -march).  */
351 static int file_ase_dsp;
352
353 #define ISA_SUPPORTS_DSP_ASE (mips_opts.isa == ISA_MIPS32R2             \
354                               || mips_opts.isa == ISA_MIPS64R2)
355
356 #define ISA_SUPPORTS_DSP64_ASE (mips_opts.isa == ISA_MIPS64R2)
357
358 /* True if -mdspr2 was passed or implied by arguments passed on the
359    command line (e.g., by -march).  */
360 static int file_ase_dspr2;
361
362 #define ISA_SUPPORTS_DSPR2_ASE (mips_opts.isa == ISA_MIPS32R2           \
363                                 || mips_opts.isa == ISA_MIPS64R2)
364
365 /* True if -mmt was passed or implied by arguments passed on the
366    command line (e.g., by -march).  */
367 static int file_ase_mt;
368
369 #define ISA_SUPPORTS_MT_ASE (mips_opts.isa == ISA_MIPS32R2              \
370                              || mips_opts.isa == ISA_MIPS64R2)
371
372 #define ISA_SUPPORTS_MCU_ASE (mips_opts.isa == ISA_MIPS32R2             \
373                               || mips_opts.isa == ISA_MIPS64R2          \
374                               || mips_opts.micromips)
375
376 /* The argument of the -march= flag.  The architecture we are assembling.  */
377 static int file_mips_arch = CPU_UNKNOWN;
378 static const char *mips_arch_string;
379
380 /* The argument of the -mtune= flag.  The architecture for which we
381    are optimizing.  */
382 static int mips_tune = CPU_UNKNOWN;
383 static const char *mips_tune_string;
384
385 /* True when generating 32-bit code for a 64-bit processor.  */
386 static int mips_32bitmode = 0;
387
388 /* True if the given ABI requires 32-bit registers.  */
389 #define ABI_NEEDS_32BIT_REGS(ABI) ((ABI) == O32_ABI)
390
391 /* Likewise 64-bit registers.  */
392 #define ABI_NEEDS_64BIT_REGS(ABI)       \
393   ((ABI) == N32_ABI                     \
394    || (ABI) == N64_ABI                  \
395    || (ABI) == O64_ABI)
396
397 /*  Return true if ISA supports 64 bit wide gp registers.  */
398 #define ISA_HAS_64BIT_REGS(ISA)         \
399   ((ISA) == ISA_MIPS3                   \
400    || (ISA) == ISA_MIPS4                \
401    || (ISA) == ISA_MIPS5                \
402    || (ISA) == ISA_MIPS64               \
403    || (ISA) == ISA_MIPS64R2)
404
405 /*  Return true if ISA supports 64 bit wide float registers.  */
406 #define ISA_HAS_64BIT_FPRS(ISA)         \
407   ((ISA) == ISA_MIPS3                   \
408    || (ISA) == ISA_MIPS4                \
409    || (ISA) == ISA_MIPS5                \
410    || (ISA) == ISA_MIPS32R2             \
411    || (ISA) == ISA_MIPS64               \
412    || (ISA) == ISA_MIPS64R2)
413
414 /* Return true if ISA supports 64-bit right rotate (dror et al.)
415    instructions.  */
416 #define ISA_HAS_DROR(ISA)               \
417   ((ISA) == ISA_MIPS64R2                \
418    || (mips_opts.micromips              \
419        && ISA_HAS_64BIT_REGS (ISA))     \
420    )
421
422 /* Return true if ISA supports 32-bit right rotate (ror et al.)
423    instructions.  */
424 #define ISA_HAS_ROR(ISA)                \
425   ((ISA) == ISA_MIPS32R2                \
426    || (ISA) == ISA_MIPS64R2             \
427    || mips_opts.ase_smartmips           \
428    || mips_opts.micromips               \
429    )
430
431 /* Return true if ISA supports single-precision floats in odd registers.  */
432 #define ISA_HAS_ODD_SINGLE_FPR(ISA)     \
433   ((ISA) == ISA_MIPS32                  \
434    || (ISA) == ISA_MIPS32R2             \
435    || (ISA) == ISA_MIPS64               \
436    || (ISA) == ISA_MIPS64R2)
437
438 /* Return true if ISA supports move to/from high part of a 64-bit
439    floating-point register. */
440 #define ISA_HAS_MXHC1(ISA)              \
441   ((ISA) == ISA_MIPS32R2                \
442    || (ISA) == ISA_MIPS64R2)
443
444 #define HAVE_32BIT_GPRS                            \
445     (mips_opts.gp32 || !ISA_HAS_64BIT_REGS (mips_opts.isa))
446
447 #define HAVE_32BIT_FPRS                            \
448     (mips_opts.fp32 || !ISA_HAS_64BIT_FPRS (mips_opts.isa))
449
450 #define HAVE_64BIT_GPRS (!HAVE_32BIT_GPRS)
451 #define HAVE_64BIT_FPRS (!HAVE_32BIT_FPRS)
452
453 #define HAVE_NEWABI (mips_abi == N32_ABI || mips_abi == N64_ABI)
454
455 #define HAVE_64BIT_OBJECTS (mips_abi == N64_ABI)
456
457 /* True if relocations are stored in-place.  */
458 #define HAVE_IN_PLACE_ADDENDS (!HAVE_NEWABI)
459
460 /* The ABI-derived address size.  */
461 #define HAVE_64BIT_ADDRESSES \
462   (HAVE_64BIT_GPRS && (mips_abi == EABI_ABI || mips_abi == N64_ABI))
463 #define HAVE_32BIT_ADDRESSES (!HAVE_64BIT_ADDRESSES)
464
465 /* The size of symbolic constants (i.e., expressions of the form
466    "SYMBOL" or "SYMBOL + OFFSET").  */
467 #define HAVE_32BIT_SYMBOLS \
468   (HAVE_32BIT_ADDRESSES || !HAVE_64BIT_OBJECTS || mips_opts.sym32)
469 #define HAVE_64BIT_SYMBOLS (!HAVE_32BIT_SYMBOLS)
470
471 /* Addresses are loaded in different ways, depending on the address size
472    in use.  The n32 ABI Documentation also mandates the use of additions
473    with overflow checking, but existing implementations don't follow it.  */
474 #define ADDRESS_ADD_INSN                                                \
475    (HAVE_32BIT_ADDRESSES ? "addu" : "daddu")
476
477 #define ADDRESS_ADDI_INSN                                               \
478    (HAVE_32BIT_ADDRESSES ? "addiu" : "daddiu")
479
480 #define ADDRESS_LOAD_INSN                                               \
481    (HAVE_32BIT_ADDRESSES ? "lw" : "ld")
482
483 #define ADDRESS_STORE_INSN                                              \
484    (HAVE_32BIT_ADDRESSES ? "sw" : "sd")
485
486 /* Return true if the given CPU supports the MIPS16 ASE.  */
487 #define CPU_HAS_MIPS16(cpu)                                             \
488    (strncmp (TARGET_CPU, "mips16", sizeof ("mips16") - 1) == 0          \
489     || strncmp (TARGET_CANONICAL, "mips-lsi-elf", sizeof ("mips-lsi-elf") - 1) == 0)
490
491 /* Return true if the given CPU supports the microMIPS ASE.  */
492 #define CPU_HAS_MICROMIPS(cpu)  0
493
494 /* True if CPU has a dror instruction.  */
495 #define CPU_HAS_DROR(CPU)       ((CPU) == CPU_VR5400 || (CPU) == CPU_VR5500)
496
497 /* True if CPU has a ror instruction.  */
498 #define CPU_HAS_ROR(CPU)        CPU_HAS_DROR (CPU)
499
500 /* True if CPU has seq/sne and seqi/snei instructions.  */
501 #define CPU_HAS_SEQ(CPU)        ((CPU) == CPU_OCTEON)
502
503 /* True if CPU does not implement the all the coprocessor insns.  For these
504    CPUs only those COP insns are accepted that are explicitly marked to be
505    available on the CPU.  ISA membership for COP insns is ignored.  */
506 #define NO_ISA_COP(CPU)         ((CPU) == CPU_OCTEON)
507
508 /* True if mflo and mfhi can be immediately followed by instructions
509    which write to the HI and LO registers.
510
511    According to MIPS specifications, MIPS ISAs I, II, and III need
512    (at least) two instructions between the reads of HI/LO and
513    instructions which write them, and later ISAs do not.  Contradicting
514    the MIPS specifications, some MIPS IV processor user manuals (e.g.
515    the UM for the NEC Vr5000) document needing the instructions between
516    HI/LO reads and writes, as well.  Therefore, we declare only MIPS32,
517    MIPS64 and later ISAs to have the interlocks, plus any specific
518    earlier-ISA CPUs for which CPU documentation declares that the
519    instructions are really interlocked.  */
520 #define hilo_interlocks \
521   (mips_opts.isa == ISA_MIPS32                        \
522    || mips_opts.isa == ISA_MIPS32R2                   \
523    || mips_opts.isa == ISA_MIPS64                     \
524    || mips_opts.isa == ISA_MIPS64R2                   \
525    || mips_opts.arch == CPU_R4010                     \
526    || mips_opts.arch == CPU_R10000                    \
527    || mips_opts.arch == CPU_R12000                    \
528    || mips_opts.arch == CPU_R14000                    \
529    || mips_opts.arch == CPU_R16000                    \
530    || mips_opts.arch == CPU_RM7000                    \
531    || mips_opts.arch == CPU_VR5500                    \
532    || mips_opts.micromips                             \
533    )
534
535 /* Whether the processor uses hardware interlocks to protect reads
536    from the GPRs after they are loaded from memory, and thus does not
537    require nops to be inserted.  This applies to instructions marked
538    INSN_LOAD_MEMORY_DELAY.  These nops are only required at MIPS ISA
539    level I and microMIPS mode instructions are always interlocked.  */
540 #define gpr_interlocks                                \
541   (mips_opts.isa != ISA_MIPS1                         \
542    || mips_opts.arch == CPU_R3900                     \
543    || mips_opts.micromips                             \
544    )
545
546 /* Whether the processor uses hardware interlocks to avoid delays
547    required by coprocessor instructions, and thus does not require
548    nops to be inserted.  This applies to instructions marked
549    INSN_LOAD_COPROC_DELAY, INSN_COPROC_MOVE_DELAY, and to delays
550    between instructions marked INSN_WRITE_COND_CODE and ones marked
551    INSN_READ_COND_CODE.  These nops are only required at MIPS ISA
552    levels I, II, and III and microMIPS mode instructions are always
553    interlocked.  */
554 /* Itbl support may require additional care here.  */
555 #define cop_interlocks                                \
556   ((mips_opts.isa != ISA_MIPS1                        \
557     && mips_opts.isa != ISA_MIPS2                     \
558     && mips_opts.isa != ISA_MIPS3)                    \
559    || mips_opts.arch == CPU_R4300                     \
560    || mips_opts.micromips                             \
561    )
562
563 /* Whether the processor uses hardware interlocks to protect reads
564    from coprocessor registers after they are loaded from memory, and
565    thus does not require nops to be inserted.  This applies to
566    instructions marked INSN_COPROC_MEMORY_DELAY.  These nops are only
567    requires at MIPS ISA level I and microMIPS mode instructions are
568    always interlocked.  */
569 #define cop_mem_interlocks                            \
570   (mips_opts.isa != ISA_MIPS1                         \
571    || mips_opts.micromips                             \
572    )
573
574 /* Is this a mfhi or mflo instruction?  */
575 #define MF_HILO_INSN(PINFO) \
576   ((PINFO & INSN_READ_HI) || (PINFO & INSN_READ_LO))
577
578 /* Returns true for a (non floating-point) coprocessor instruction.  Reading
579    or writing the condition code is only possible on the coprocessors and
580    these insns are not marked with INSN_COP.  Thus for these insns use the
581    condition-code flags.  */
582 #define COP_INSN(PINFO)                                                 \
583   (PINFO != INSN_MACRO                                                  \
584    && ((PINFO) & (FP_S | FP_D)) == 0                                    \
585    && ((PINFO) & (INSN_COP | INSN_READ_COND_CODE | INSN_WRITE_COND_CODE)))
586
587 /* Whether code compression (either of the MIPS16 or the microMIPS ASEs)
588    has been selected.  This implies, in particular, that addresses of text
589    labels have their LSB set.  */
590 #define HAVE_CODE_COMPRESSION                                           \
591   ((mips_opts.mips16 | mips_opts.micromips) != 0)
592
593 /* MIPS PIC level.  */
594
595 enum mips_pic_level mips_pic;
596
597 /* 1 if we should generate 32 bit offsets from the $gp register in
598    SVR4_PIC mode.  Currently has no meaning in other modes.  */
599 static int mips_big_got = 0;
600
601 /* 1 if trap instructions should used for overflow rather than break
602    instructions.  */
603 static int mips_trap = 0;
604
605 /* 1 if double width floating point constants should not be constructed
606    by assembling two single width halves into two single width floating
607    point registers which just happen to alias the double width destination
608    register.  On some architectures this aliasing can be disabled by a bit
609    in the status register, and the setting of this bit cannot be determined
610    automatically at assemble time.  */
611 static int mips_disable_float_construction;
612
613 /* Non-zero if any .set noreorder directives were used.  */
614
615 static int mips_any_noreorder;
616
617 /* Non-zero if nops should be inserted when the register referenced in
618    an mfhi/mflo instruction is read in the next two instructions.  */
619 static int mips_7000_hilo_fix;
620
621 /* The size of objects in the small data section.  */
622 static unsigned int g_switch_value = 8;
623 /* Whether the -G option was used.  */
624 static int g_switch_seen = 0;
625
626 #define N_RMASK 0xc4
627 #define N_VFP   0xd4
628
629 /* If we can determine in advance that GP optimization won't be
630    possible, we can skip the relaxation stuff that tries to produce
631    GP-relative references.  This makes delay slot optimization work
632    better.
633
634    This function can only provide a guess, but it seems to work for
635    gcc output.  It needs to guess right for gcc, otherwise gcc
636    will put what it thinks is a GP-relative instruction in a branch
637    delay slot.
638
639    I don't know if a fix is needed for the SVR4_PIC mode.  I've only
640    fixed it for the non-PIC mode.  KR 95/04/07  */
641 static int nopic_need_relax (symbolS *, int);
642
643 /* handle of the OPCODE hash table */
644 static struct hash_control *op_hash = NULL;
645
646 /* The opcode hash table we use for the mips16.  */
647 static struct hash_control *mips16_op_hash = NULL;
648
649 /* The opcode hash table we use for the microMIPS ASE.  */
650 static struct hash_control *micromips_op_hash = NULL;
651
652 /* This array holds the chars that always start a comment.  If the
653     pre-processor is disabled, these aren't very useful */
654 const char comment_chars[] = "#";
655
656 /* This array holds the chars that only start a comment at the beginning of
657    a line.  If the line seems to have the form '# 123 filename'
658    .line and .file directives will appear in the pre-processed output */
659 /* Note that input_file.c hand checks for '#' at the beginning of the
660    first line of the input file.  This is because the compiler outputs
661    #NO_APP at the beginning of its output.  */
662 /* Also note that C style comments are always supported.  */
663 const char line_comment_chars[] = "#";
664
665 /* This array holds machine specific line separator characters.  */
666 const char line_separator_chars[] = ";";
667
668 /* Chars that can be used to separate mant from exp in floating point nums */
669 const char EXP_CHARS[] = "eE";
670
671 /* Chars that mean this number is a floating point constant */
672 /* As in 0f12.456 */
673 /* or    0d1.2345e12 */
674 const char FLT_CHARS[] = "rRsSfFdDxXpP";
675
676 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
677    changed in read.c .  Ideally it shouldn't have to know about it at all,
678    but nothing is ideal around here.
679  */
680
681 static char *insn_error;
682
683 static int auto_align = 1;
684
685 /* When outputting SVR4 PIC code, the assembler needs to know the
686    offset in the stack frame from which to restore the $gp register.
687    This is set by the .cprestore pseudo-op, and saved in this
688    variable.  */
689 static offsetT mips_cprestore_offset = -1;
690
691 /* Similar for NewABI PIC code, where $gp is callee-saved.  NewABI has some
692    more optimizations, it can use a register value instead of a memory-saved
693    offset and even an other register than $gp as global pointer.  */
694 static offsetT mips_cpreturn_offset = -1;
695 static int mips_cpreturn_register = -1;
696 static int mips_gp_register = GP;
697 static int mips_gprel_offset = 0;
698
699 /* Whether mips_cprestore_offset has been set in the current function
700    (or whether it has already been warned about, if not).  */
701 static int mips_cprestore_valid = 0;
702
703 /* This is the register which holds the stack frame, as set by the
704    .frame pseudo-op.  This is needed to implement .cprestore.  */
705 static int mips_frame_reg = SP;
706
707 /* Whether mips_frame_reg has been set in the current function
708    (or whether it has already been warned about, if not).  */
709 static int mips_frame_reg_valid = 0;
710
711 /* To output NOP instructions correctly, we need to keep information
712    about the previous two instructions.  */
713
714 /* Whether we are optimizing.  The default value of 2 means to remove
715    unneeded NOPs and swap branch instructions when possible.  A value
716    of 1 means to not swap branches.  A value of 0 means to always
717    insert NOPs.  */
718 static int mips_optimize = 2;
719
720 /* Debugging level.  -g sets this to 2.  -gN sets this to N.  -g0 is
721    equivalent to seeing no -g option at all.  */
722 static int mips_debug = 0;
723
724 /* The maximum number of NOPs needed to avoid the VR4130 mflo/mfhi errata.  */
725 #define MAX_VR4130_NOPS 4
726
727 /* The maximum number of NOPs needed to fill delay slots.  */
728 #define MAX_DELAY_NOPS 2
729
730 /* The maximum number of NOPs needed for any purpose.  */
731 #define MAX_NOPS 4
732
733 /* A list of previous instructions, with index 0 being the most recent.
734    We need to look back MAX_NOPS instructions when filling delay slots
735    or working around processor errata.  We need to look back one
736    instruction further if we're thinking about using history[0] to
737    fill a branch delay slot.  */
738 static struct mips_cl_insn history[1 + MAX_NOPS];
739
740 /* Nop instructions used by emit_nop.  */
741 static struct mips_cl_insn nop_insn;
742 static struct mips_cl_insn mips16_nop_insn;
743 static struct mips_cl_insn micromips_nop16_insn;
744 static struct mips_cl_insn micromips_nop32_insn;
745
746 /* The appropriate nop for the current mode.  */
747 #define NOP_INSN (mips_opts.mips16 ? &mips16_nop_insn \
748                   : (mips_opts.micromips ? &micromips_nop16_insn : &nop_insn))
749
750 /* The size of NOP_INSN in bytes.  */
751 #define NOP_INSN_SIZE (HAVE_CODE_COMPRESSION ? 2 : 4)
752
753 /* If this is set, it points to a frag holding nop instructions which
754    were inserted before the start of a noreorder section.  If those
755    nops turn out to be unnecessary, the size of the frag can be
756    decreased.  */
757 static fragS *prev_nop_frag;
758
759 /* The number of nop instructions we created in prev_nop_frag.  */
760 static int prev_nop_frag_holds;
761
762 /* The number of nop instructions that we know we need in
763    prev_nop_frag.  */
764 static int prev_nop_frag_required;
765
766 /* The number of instructions we've seen since prev_nop_frag.  */
767 static int prev_nop_frag_since;
768
769 /* For ECOFF and ELF, relocations against symbols are done in two
770    parts, with a HI relocation and a LO relocation.  Each relocation
771    has only 16 bits of space to store an addend.  This means that in
772    order for the linker to handle carries correctly, it must be able
773    to locate both the HI and the LO relocation.  This means that the
774    relocations must appear in order in the relocation table.
775
776    In order to implement this, we keep track of each unmatched HI
777    relocation.  We then sort them so that they immediately precede the
778    corresponding LO relocation.  */
779
780 struct mips_hi_fixup
781 {
782   /* Next HI fixup.  */
783   struct mips_hi_fixup *next;
784   /* This fixup.  */
785   fixS *fixp;
786   /* The section this fixup is in.  */
787   segT seg;
788 };
789
790 /* The list of unmatched HI relocs.  */
791
792 static struct mips_hi_fixup *mips_hi_fixup_list;
793
794 /* The frag containing the last explicit relocation operator.
795    Null if explicit relocations have not been used.  */
796
797 static fragS *prev_reloc_op_frag;
798
799 /* Map normal MIPS register numbers to mips16 register numbers.  */
800
801 #define X ILLEGAL_REG
802 static const int mips32_to_16_reg_map[] =
803 {
804   X, X, 2, 3, 4, 5, 6, 7,
805   X, X, X, X, X, X, X, X,
806   0, 1, X, X, X, X, X, X,
807   X, X, X, X, X, X, X, X
808 };
809 #undef X
810
811 /* Map mips16 register numbers to normal MIPS register numbers.  */
812
813 static const unsigned int mips16_to_32_reg_map[] =
814 {
815   16, 17, 2, 3, 4, 5, 6, 7
816 };
817
818 /* Map normal MIPS register numbers to microMIPS register numbers.  */
819
820 #define mips32_to_micromips_reg_b_map   mips32_to_16_reg_map
821 #define mips32_to_micromips_reg_c_map   mips32_to_16_reg_map
822 #define mips32_to_micromips_reg_d_map   mips32_to_16_reg_map
823 #define mips32_to_micromips_reg_e_map   mips32_to_16_reg_map
824 #define mips32_to_micromips_reg_f_map   mips32_to_16_reg_map
825 #define mips32_to_micromips_reg_g_map   mips32_to_16_reg_map
826 #define mips32_to_micromips_reg_l_map   mips32_to_16_reg_map
827
828 #define X ILLEGAL_REG
829 /* reg type h: 4, 5, 6.  */
830 static const int mips32_to_micromips_reg_h_map[] =
831 {
832   X, X, X, X, 4, 5, 6, X,
833   X, X, X, X, X, X, X, X,
834   X, X, X, X, X, X, X, X,
835   X, X, X, X, X, X, X, X
836 };
837
838 /* reg type m: 0, 17, 2, 3, 16, 18, 19, 20.  */
839 static const int mips32_to_micromips_reg_m_map[] =
840 {
841   0, X, 2, 3, X, X, X, X,
842   X, X, X, X, X, X, X, X,
843   4, 1, 5, 6, 7, X, X, X,
844   X, X, X, X, X, X, X, X
845 };
846
847 /* reg type q: 0, 2-7. 17.  */
848 static const int mips32_to_micromips_reg_q_map[] =
849 {
850   0, X, 2, 3, 4, 5, 6, 7,
851   X, X, X, X, X, X, X, X,
852   X, 1, X, X, X, X, X, X,
853   X, X, X, X, X, X, X, X
854 };
855
856 #define mips32_to_micromips_reg_n_map  mips32_to_micromips_reg_m_map
857 #undef X
858
859 /* Map microMIPS register numbers to normal MIPS register numbers.  */
860
861 #define micromips_to_32_reg_b_map       mips16_to_32_reg_map
862 #define micromips_to_32_reg_c_map       mips16_to_32_reg_map
863 #define micromips_to_32_reg_d_map       mips16_to_32_reg_map
864 #define micromips_to_32_reg_e_map       mips16_to_32_reg_map
865 #define micromips_to_32_reg_f_map       mips16_to_32_reg_map
866 #define micromips_to_32_reg_g_map       mips16_to_32_reg_map
867
868 /* The microMIPS registers with type h.  */
869 static const unsigned int micromips_to_32_reg_h_map[] =
870 {
871   5, 5, 6, 4, 4, 4, 4, 4
872 };
873
874 /* The microMIPS registers with type i.  */
875 static const unsigned int micromips_to_32_reg_i_map[] =
876 {
877   6, 7, 7, 21, 22, 5, 6, 7
878 };
879
880 #define micromips_to_32_reg_l_map       mips16_to_32_reg_map
881
882 /* The microMIPS registers with type m.  */
883 static const unsigned int micromips_to_32_reg_m_map[] =
884 {
885   0, 17, 2, 3, 16, 18, 19, 20
886 };
887
888 #define micromips_to_32_reg_n_map      micromips_to_32_reg_m_map
889
890 /* The microMIPS registers with type q.  */
891 static const unsigned int micromips_to_32_reg_q_map[] =
892 {
893   0, 17, 2, 3, 4, 5, 6, 7
894 };
895
896 /* microMIPS imm type B.  */
897 static const int micromips_imm_b_map[] =
898 {
899   1, 4, 8, 12, 16, 20, 24, -1
900 };
901
902 /* microMIPS imm type C.  */
903 static const int micromips_imm_c_map[] =
904 {
905   128, 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 255, 32768, 65535
906 };
907
908 /* Classifies the kind of instructions we're interested in when
909    implementing -mfix-vr4120.  */
910 enum fix_vr4120_class
911 {
912   FIX_VR4120_MACC,
913   FIX_VR4120_DMACC,
914   FIX_VR4120_MULT,
915   FIX_VR4120_DMULT,
916   FIX_VR4120_DIV,
917   FIX_VR4120_MTHILO,
918   NUM_FIX_VR4120_CLASSES
919 };
920
921 /* ...likewise -mfix-loongson2f-jump.  */
922 static bfd_boolean mips_fix_loongson2f_jump;
923
924 /* ...likewise -mfix-loongson2f-nop.  */
925 static bfd_boolean mips_fix_loongson2f_nop;
926
927 /* True if -mfix-loongson2f-nop or -mfix-loongson2f-jump passed.  */
928 static bfd_boolean mips_fix_loongson2f;
929
930 /* Given two FIX_VR4120_* values X and Y, bit Y of element X is set if
931    there must be at least one other instruction between an instruction
932    of type X and an instruction of type Y.  */
933 static unsigned int vr4120_conflicts[NUM_FIX_VR4120_CLASSES];
934
935 /* True if -mfix-vr4120 is in force.  */
936 static int mips_fix_vr4120;
937
938 /* ...likewise -mfix-vr4130.  */
939 static int mips_fix_vr4130;
940
941 /* ...likewise -mfix-24k.  */
942 static int mips_fix_24k;
943
944 /* ...likewise -mfix-cn63xxp1 */
945 static bfd_boolean mips_fix_cn63xxp1;
946
947 /* We don't relax branches by default, since this causes us to expand
948    `la .l2 - .l1' if there's a branch between .l1 and .l2, because we
949    fail to compute the offset before expanding the macro to the most
950    efficient expansion.  */
951
952 static int mips_relax_branch;
953 \f
954 /* The expansion of many macros depends on the type of symbol that
955    they refer to.  For example, when generating position-dependent code,
956    a macro that refers to a symbol may have two different expansions,
957    one which uses GP-relative addresses and one which uses absolute
958    addresses.  When generating SVR4-style PIC, a macro may have
959    different expansions for local and global symbols.
960
961    We handle these situations by generating both sequences and putting
962    them in variant frags.  In position-dependent code, the first sequence
963    will be the GP-relative one and the second sequence will be the
964    absolute one.  In SVR4 PIC, the first sequence will be for global
965    symbols and the second will be for local symbols.
966
967    The frag's "subtype" is RELAX_ENCODE (FIRST, SECOND), where FIRST and
968    SECOND are the lengths of the two sequences in bytes.  These fields
969    can be extracted using RELAX_FIRST() and RELAX_SECOND().  In addition,
970    the subtype has the following flags:
971
972    RELAX_USE_SECOND
973         Set if it has been decided that we should use the second
974         sequence instead of the first.
975
976    RELAX_SECOND_LONGER
977         Set in the first variant frag if the macro's second implementation
978         is longer than its first.  This refers to the macro as a whole,
979         not an individual relaxation.
980
981    RELAX_NOMACRO
982         Set in the first variant frag if the macro appeared in a .set nomacro
983         block and if one alternative requires a warning but the other does not.
984
985    RELAX_DELAY_SLOT
986         Like RELAX_NOMACRO, but indicates that the macro appears in a branch
987         delay slot.
988
989    RELAX_DELAY_SLOT_16BIT
990         Like RELAX_DELAY_SLOT, but indicates that the delay slot requires a
991         16-bit instruction.
992
993    RELAX_DELAY_SLOT_SIZE_FIRST
994         Like RELAX_DELAY_SLOT, but indicates that the first implementation of
995         the macro is of the wrong size for the branch delay slot.
996
997    RELAX_DELAY_SLOT_SIZE_SECOND
998         Like RELAX_DELAY_SLOT, but indicates that the second implementation of
999         the macro is of the wrong size for the branch delay slot.
1000
1001    The frag's "opcode" points to the first fixup for relaxable code.
1002
1003    Relaxable macros are generated using a sequence such as:
1004
1005       relax_start (SYMBOL);
1006       ... generate first expansion ...
1007       relax_switch ();
1008       ... generate second expansion ...
1009       relax_end ();
1010
1011    The code and fixups for the unwanted alternative are discarded
1012    by md_convert_frag.  */
1013 #define RELAX_ENCODE(FIRST, SECOND) (((FIRST) << 8) | (SECOND))
1014
1015 #define RELAX_FIRST(X) (((X) >> 8) & 0xff)
1016 #define RELAX_SECOND(X) ((X) & 0xff)
1017 #define RELAX_USE_SECOND 0x10000
1018 #define RELAX_SECOND_LONGER 0x20000
1019 #define RELAX_NOMACRO 0x40000
1020 #define RELAX_DELAY_SLOT 0x80000
1021 #define RELAX_DELAY_SLOT_16BIT 0x100000
1022 #define RELAX_DELAY_SLOT_SIZE_FIRST 0x200000
1023 #define RELAX_DELAY_SLOT_SIZE_SECOND 0x400000
1024
1025 /* Branch without likely bit.  If label is out of range, we turn:
1026
1027         beq reg1, reg2, label
1028         delay slot
1029
1030    into
1031
1032         bne reg1, reg2, 0f
1033         nop
1034         j label
1035      0: delay slot
1036
1037    with the following opcode replacements:
1038
1039         beq <-> bne
1040         blez <-> bgtz
1041         bltz <-> bgez
1042         bc1f <-> bc1t
1043
1044         bltzal <-> bgezal  (with jal label instead of j label)
1045
1046    Even though keeping the delay slot instruction in the delay slot of
1047    the branch would be more efficient, it would be very tricky to do
1048    correctly, because we'd have to introduce a variable frag *after*
1049    the delay slot instruction, and expand that instead.  Let's do it
1050    the easy way for now, even if the branch-not-taken case now costs
1051    one additional instruction.  Out-of-range branches are not supposed
1052    to be common, anyway.
1053
1054    Branch likely.  If label is out of range, we turn:
1055
1056         beql reg1, reg2, label
1057         delay slot (annulled if branch not taken)
1058
1059    into
1060
1061         beql reg1, reg2, 1f
1062         nop
1063         beql $0, $0, 2f
1064         nop
1065      1: j[al] label
1066         delay slot (executed only if branch taken)
1067      2:
1068
1069    It would be possible to generate a shorter sequence by losing the
1070    likely bit, generating something like:
1071
1072         bne reg1, reg2, 0f
1073         nop
1074         j[al] label
1075         delay slot (executed only if branch taken)
1076      0:
1077
1078         beql -> bne
1079         bnel -> beq
1080         blezl -> bgtz
1081         bgtzl -> blez
1082         bltzl -> bgez
1083         bgezl -> bltz
1084         bc1fl -> bc1t
1085         bc1tl -> bc1f
1086
1087         bltzall -> bgezal  (with jal label instead of j label)
1088         bgezall -> bltzal  (ditto)
1089
1090
1091    but it's not clear that it would actually improve performance.  */
1092 #define RELAX_BRANCH_ENCODE(at, uncond, likely, link, toofar)   \
1093   ((relax_substateT)                                            \
1094    (0xc0000000                                                  \
1095     | ((at) & 0x1f)                                             \
1096     | ((toofar) ? 0x20 : 0)                                     \
1097     | ((link) ? 0x40 : 0)                                       \
1098     | ((likely) ? 0x80 : 0)                                     \
1099     | ((uncond) ? 0x100 : 0)))
1100 #define RELAX_BRANCH_P(i) (((i) & 0xf0000000) == 0xc0000000)
1101 #define RELAX_BRANCH_UNCOND(i) (((i) & 0x100) != 0)
1102 #define RELAX_BRANCH_LIKELY(i) (((i) & 0x80) != 0)
1103 #define RELAX_BRANCH_LINK(i) (((i) & 0x40) != 0)
1104 #define RELAX_BRANCH_TOOFAR(i) (((i) & 0x20) != 0)
1105 #define RELAX_BRANCH_AT(i) ((i) & 0x1f)
1106
1107 /* For mips16 code, we use an entirely different form of relaxation.
1108    mips16 supports two versions of most instructions which take
1109    immediate values: a small one which takes some small value, and a
1110    larger one which takes a 16 bit value.  Since branches also follow
1111    this pattern, relaxing these values is required.
1112
1113    We can assemble both mips16 and normal MIPS code in a single
1114    object.  Therefore, we need to support this type of relaxation at
1115    the same time that we support the relaxation described above.  We
1116    use the high bit of the subtype field to distinguish these cases.
1117
1118    The information we store for this type of relaxation is the
1119    argument code found in the opcode file for this relocation, whether
1120    the user explicitly requested a small or extended form, and whether
1121    the relocation is in a jump or jal delay slot.  That tells us the
1122    size of the value, and how it should be stored.  We also store
1123    whether the fragment is considered to be extended or not.  We also
1124    store whether this is known to be a branch to a different section,
1125    whether we have tried to relax this frag yet, and whether we have
1126    ever extended a PC relative fragment because of a shift count.  */
1127 #define RELAX_MIPS16_ENCODE(type, small, ext, dslot, jal_dslot) \
1128   (0x80000000                                                   \
1129    | ((type) & 0xff)                                            \
1130    | ((small) ? 0x100 : 0)                                      \
1131    | ((ext) ? 0x200 : 0)                                        \
1132    | ((dslot) ? 0x400 : 0)                                      \
1133    | ((jal_dslot) ? 0x800 : 0))
1134 #define RELAX_MIPS16_P(i) (((i) & 0xc0000000) == 0x80000000)
1135 #define RELAX_MIPS16_TYPE(i) ((i) & 0xff)
1136 #define RELAX_MIPS16_USER_SMALL(i) (((i) & 0x100) != 0)
1137 #define RELAX_MIPS16_USER_EXT(i) (((i) & 0x200) != 0)
1138 #define RELAX_MIPS16_DSLOT(i) (((i) & 0x400) != 0)
1139 #define RELAX_MIPS16_JAL_DSLOT(i) (((i) & 0x800) != 0)
1140 #define RELAX_MIPS16_EXTENDED(i) (((i) & 0x1000) != 0)
1141 #define RELAX_MIPS16_MARK_EXTENDED(i) ((i) | 0x1000)
1142 #define RELAX_MIPS16_CLEAR_EXTENDED(i) ((i) &~ 0x1000)
1143 #define RELAX_MIPS16_LONG_BRANCH(i) (((i) & 0x2000) != 0)
1144 #define RELAX_MIPS16_MARK_LONG_BRANCH(i) ((i) | 0x2000)
1145 #define RELAX_MIPS16_CLEAR_LONG_BRANCH(i) ((i) &~ 0x2000)
1146
1147 /* For microMIPS code, we use relaxation similar to one we use for
1148    MIPS16 code.  Some instructions that take immediate values support
1149    two encodings: a small one which takes some small value, and a
1150    larger one which takes a 16 bit value.  As some branches also follow
1151    this pattern, relaxing these values is required.
1152
1153    We can assemble both microMIPS and normal MIPS code in a single
1154    object.  Therefore, we need to support this type of relaxation at
1155    the same time that we support the relaxation described above.  We
1156    use one of the high bits of the subtype field to distinguish these
1157    cases.
1158
1159    The information we store for this type of relaxation is the argument
1160    code found in the opcode file for this relocation, the register
1161    selected as the assembler temporary, whether the branch is
1162    unconditional, whether it is compact, whether it stores the link
1163    address implicitly in $ra, whether relaxation of out-of-range 32-bit
1164    branches to a sequence of instructions is enabled, and whether the
1165    displacement of a branch is too large to fit as an immediate argument
1166    of a 16-bit and a 32-bit branch, respectively.  */
1167 #define RELAX_MICROMIPS_ENCODE(type, at, uncond, compact, link, \
1168                                relax32, toofar16, toofar32)     \
1169   (0x40000000                                                   \
1170    | ((type) & 0xff)                                            \
1171    | (((at) & 0x1f) << 8)                                       \
1172    | ((uncond) ? 0x2000 : 0)                                    \
1173    | ((compact) ? 0x4000 : 0)                                   \
1174    | ((link) ? 0x8000 : 0)                                      \
1175    | ((relax32) ? 0x10000 : 0)                                  \
1176    | ((toofar16) ? 0x20000 : 0)                                 \
1177    | ((toofar32) ? 0x40000 : 0))
1178 #define RELAX_MICROMIPS_P(i) (((i) & 0xc0000000) == 0x40000000)
1179 #define RELAX_MICROMIPS_TYPE(i) ((i) & 0xff)
1180 #define RELAX_MICROMIPS_AT(i) (((i) >> 8) & 0x1f)
1181 #define RELAX_MICROMIPS_UNCOND(i) (((i) & 0x2000) != 0)
1182 #define RELAX_MICROMIPS_COMPACT(i) (((i) & 0x4000) != 0)
1183 #define RELAX_MICROMIPS_LINK(i) (((i) & 0x8000) != 0)
1184 #define RELAX_MICROMIPS_RELAX32(i) (((i) & 0x10000) != 0)
1185
1186 #define RELAX_MICROMIPS_TOOFAR16(i) (((i) & 0x20000) != 0)
1187 #define RELAX_MICROMIPS_MARK_TOOFAR16(i) ((i) | 0x20000)
1188 #define RELAX_MICROMIPS_CLEAR_TOOFAR16(i) ((i) & ~0x20000)
1189 #define RELAX_MICROMIPS_TOOFAR32(i) (((i) & 0x40000) != 0)
1190 #define RELAX_MICROMIPS_MARK_TOOFAR32(i) ((i) | 0x40000)
1191 #define RELAX_MICROMIPS_CLEAR_TOOFAR32(i) ((i) & ~0x40000)
1192
1193 /* Is the given value a sign-extended 32-bit value?  */
1194 #define IS_SEXT_32BIT_NUM(x)                                            \
1195   (((x) &~ (offsetT) 0x7fffffff) == 0                                   \
1196    || (((x) &~ (offsetT) 0x7fffffff) == ~ (offsetT) 0x7fffffff))
1197
1198 /* Is the given value a sign-extended 16-bit value?  */
1199 #define IS_SEXT_16BIT_NUM(x)                                            \
1200   (((x) &~ (offsetT) 0x7fff) == 0                                       \
1201    || (((x) &~ (offsetT) 0x7fff) == ~ (offsetT) 0x7fff))
1202
1203 /* Is the given value a sign-extended 12-bit value?  */
1204 #define IS_SEXT_12BIT_NUM(x)                                            \
1205   (((((x) & 0xfff) ^ 0x800LL) - 0x800LL) == (x))
1206
1207 /* Is the given value a zero-extended 32-bit value?  Or a negated one?  */
1208 #define IS_ZEXT_32BIT_NUM(x)                                            \
1209   (((x) &~ (offsetT) 0xffffffff) == 0                                   \
1210    || (((x) &~ (offsetT) 0xffffffff) == ~ (offsetT) 0xffffffff))
1211
1212 /* Replace bits MASK << SHIFT of STRUCT with the equivalent bits in
1213    VALUE << SHIFT.  VALUE is evaluated exactly once.  */
1214 #define INSERT_BITS(STRUCT, VALUE, MASK, SHIFT) \
1215   (STRUCT) = (((STRUCT) & ~((MASK) << (SHIFT))) \
1216               | (((VALUE) & (MASK)) << (SHIFT)))
1217
1218 /* Extract bits MASK << SHIFT from STRUCT and shift them right
1219    SHIFT places.  */
1220 #define EXTRACT_BITS(STRUCT, MASK, SHIFT) \
1221   (((STRUCT) >> (SHIFT)) & (MASK))
1222
1223 /* Change INSN's opcode so that the operand given by FIELD has value VALUE.
1224    INSN is a mips_cl_insn structure and VALUE is evaluated exactly once.
1225
1226    include/opcode/mips.h specifies operand fields using the macros
1227    OP_MASK_<FIELD> and OP_SH_<FIELD>.  The MIPS16 equivalents start
1228    with "MIPS16OP" instead of "OP".  */
1229 #define INSERT_OPERAND(MICROMIPS, FIELD, INSN, VALUE) \
1230   do \
1231     if (!(MICROMIPS)) \
1232       INSERT_BITS ((INSN).insn_opcode, VALUE, \
1233                    OP_MASK_##FIELD, OP_SH_##FIELD); \
1234     else \
1235       INSERT_BITS ((INSN).insn_opcode, VALUE, \
1236                    MICROMIPSOP_MASK_##FIELD, MICROMIPSOP_SH_##FIELD); \
1237   while (0)
1238 #define MIPS16_INSERT_OPERAND(FIELD, INSN, VALUE) \
1239   INSERT_BITS ((INSN).insn_opcode, VALUE, \
1240                 MIPS16OP_MASK_##FIELD, MIPS16OP_SH_##FIELD)
1241
1242 /* Extract the operand given by FIELD from mips_cl_insn INSN.  */
1243 #define EXTRACT_OPERAND(MICROMIPS, FIELD, INSN) \
1244   (!(MICROMIPS) \
1245    ? EXTRACT_BITS ((INSN).insn_opcode, OP_MASK_##FIELD, OP_SH_##FIELD) \
1246    : EXTRACT_BITS ((INSN).insn_opcode, \
1247                    MICROMIPSOP_MASK_##FIELD, MICROMIPSOP_SH_##FIELD))
1248 #define MIPS16_EXTRACT_OPERAND(FIELD, INSN) \
1249   EXTRACT_BITS ((INSN).insn_opcode, \
1250                 MIPS16OP_MASK_##FIELD, \
1251                 MIPS16OP_SH_##FIELD)
1252 \f
1253 /* Whether or not we are emitting a branch-likely macro.  */
1254 static bfd_boolean emit_branch_likely_macro = FALSE;
1255
1256 /* Global variables used when generating relaxable macros.  See the
1257    comment above RELAX_ENCODE for more details about how relaxation
1258    is used.  */
1259 static struct {
1260   /* 0 if we're not emitting a relaxable macro.
1261      1 if we're emitting the first of the two relaxation alternatives.
1262      2 if we're emitting the second alternative.  */
1263   int sequence;
1264
1265   /* The first relaxable fixup in the current frag.  (In other words,
1266      the first fixup that refers to relaxable code.)  */
1267   fixS *first_fixup;
1268
1269   /* sizes[0] says how many bytes of the first alternative are stored in
1270      the current frag.  Likewise sizes[1] for the second alternative.  */
1271   unsigned int sizes[2];
1272
1273   /* The symbol on which the choice of sequence depends.  */
1274   symbolS *symbol;
1275 } mips_relax;
1276 \f
1277 /* Global variables used to decide whether a macro needs a warning.  */
1278 static struct {
1279   /* True if the macro is in a branch delay slot.  */
1280   bfd_boolean delay_slot_p;
1281
1282   /* Set to the length in bytes required if the macro is in a delay slot
1283      that requires a specific length of instruction, otherwise zero.  */
1284   unsigned int delay_slot_length;
1285
1286   /* For relaxable macros, sizes[0] is the length of the first alternative
1287      in bytes and sizes[1] is the length of the second alternative.
1288      For non-relaxable macros, both elements give the length of the
1289      macro in bytes.  */
1290   unsigned int sizes[2];
1291
1292   /* For relaxable macros, first_insn_sizes[0] is the length of the first
1293      instruction of the first alternative in bytes and first_insn_sizes[1]
1294      is the length of the first instruction of the second alternative.
1295      For non-relaxable macros, both elements give the length of the first
1296      instruction in bytes.
1297
1298      Set to zero if we haven't yet seen the first instruction.  */
1299   unsigned int first_insn_sizes[2];
1300
1301   /* For relaxable macros, insns[0] is the number of instructions for the
1302      first alternative and insns[1] is the number of instructions for the
1303      second alternative.
1304
1305      For non-relaxable macros, both elements give the number of
1306      instructions for the macro.  */
1307   unsigned int insns[2];
1308
1309   /* The first variant frag for this macro.  */
1310   fragS *first_frag;
1311 } mips_macro_warning;
1312 \f
1313 /* Prototypes for static functions.  */
1314
1315 #define internalError()                                                 \
1316     as_fatal (_("internal Error, line %d, %s"), __LINE__, __FILE__)
1317
1318 enum mips_regclass { MIPS_GR_REG, MIPS_FP_REG, MIPS16_REG };
1319
1320 static void append_insn
1321   (struct mips_cl_insn *, expressionS *, bfd_reloc_code_real_type *,
1322    bfd_boolean expansionp);
1323 static void mips_no_prev_insn (void);
1324 static void macro_build (expressionS *, const char *, const char *, ...);
1325 static void mips16_macro_build
1326   (expressionS *, const char *, const char *, va_list *);
1327 static void load_register (int, expressionS *, int);
1328 static void macro_start (void);
1329 static void macro_end (void);
1330 static void macro (struct mips_cl_insn * ip);
1331 static void mips16_macro (struct mips_cl_insn * ip);
1332 static void mips_ip (char *str, struct mips_cl_insn * ip);
1333 static void mips16_ip (char *str, struct mips_cl_insn * ip);
1334 static void mips16_immed
1335   (char *, unsigned int, int, offsetT, bfd_boolean, bfd_boolean, bfd_boolean,
1336    unsigned long *, bfd_boolean *, unsigned short *);
1337 static size_t my_getSmallExpression
1338   (expressionS *, bfd_reloc_code_real_type *, char *);
1339 static void my_getExpression (expressionS *, char *);
1340 static void s_align (int);
1341 static void s_change_sec (int);
1342 static void s_change_section (int);
1343 static void s_cons (int);
1344 static void s_float_cons (int);
1345 static void s_mips_globl (int);
1346 static void s_option (int);
1347 static void s_mipsset (int);
1348 static void s_abicalls (int);
1349 static void s_cpload (int);
1350 static void s_cpsetup (int);
1351 static void s_cplocal (int);
1352 static void s_cprestore (int);
1353 static void s_cpreturn (int);
1354 static void s_dtprelword (int);
1355 static void s_dtpreldword (int);
1356 static void s_gpvalue (int);
1357 static void s_gpword (int);
1358 static void s_gpdword (int);
1359 static void s_cpadd (int);
1360 static void s_insn (int);
1361 static void md_obj_begin (void);
1362 static void md_obj_end (void);
1363 static void s_mips_ent (int);
1364 static void s_mips_end (int);
1365 static void s_mips_frame (int);
1366 static void s_mips_mask (int reg_type);
1367 static void s_mips_stab (int);
1368 static void s_mips_weakext (int);
1369 static void s_mips_file (int);
1370 static void s_mips_loc (int);
1371 static bfd_boolean pic_need_relax (symbolS *, asection *);
1372 static int relaxed_branch_length (fragS *, asection *, int);
1373 static int validate_mips_insn (const struct mips_opcode *);
1374 static int validate_micromips_insn (const struct mips_opcode *);
1375 static int relaxed_micromips_16bit_branch_length (fragS *, asection *, int);
1376 static int relaxed_micromips_32bit_branch_length (fragS *, asection *, int);
1377
1378 /* Table and functions used to map between CPU/ISA names, and
1379    ISA levels, and CPU numbers.  */
1380
1381 struct mips_cpu_info
1382 {
1383   const char *name;           /* CPU or ISA name.  */
1384   int flags;                  /* ASEs available, or ISA flag.  */
1385   int isa;                    /* ISA level.  */
1386   int cpu;                    /* CPU number (default CPU if ISA).  */
1387 };
1388
1389 #define MIPS_CPU_IS_ISA         0x0001  /* Is this an ISA?  (If 0, a CPU.) */
1390 #define MIPS_CPU_ASE_SMARTMIPS  0x0002  /* CPU implements SmartMIPS ASE */
1391 #define MIPS_CPU_ASE_DSP        0x0004  /* CPU implements DSP ASE */
1392 #define MIPS_CPU_ASE_MT         0x0008  /* CPU implements MT ASE */
1393 #define MIPS_CPU_ASE_MIPS3D     0x0010  /* CPU implements MIPS-3D ASE */
1394 #define MIPS_CPU_ASE_MDMX       0x0020  /* CPU implements MDMX ASE */
1395 #define MIPS_CPU_ASE_DSPR2      0x0040  /* CPU implements DSP R2 ASE */
1396 #define MIPS_CPU_ASE_MCU        0x0080  /* CPU implements MCU ASE */
1397
1398 static const struct mips_cpu_info *mips_parse_cpu (const char *, const char *);
1399 static const struct mips_cpu_info *mips_cpu_info_from_isa (int);
1400 static const struct mips_cpu_info *mips_cpu_info_from_arch (int);
1401 \f
1402 /* Pseudo-op table.
1403
1404    The following pseudo-ops from the Kane and Heinrich MIPS book
1405    should be defined here, but are currently unsupported: .alias,
1406    .galive, .gjaldef, .gjrlive, .livereg, .noalias.
1407
1408    The following pseudo-ops from the Kane and Heinrich MIPS book are
1409    specific to the type of debugging information being generated, and
1410    should be defined by the object format: .aent, .begin, .bend,
1411    .bgnb, .end, .endb, .ent, .fmask, .frame, .loc, .mask, .verstamp,
1412    .vreg.
1413
1414    The following pseudo-ops from the Kane and Heinrich MIPS book are
1415    not MIPS CPU specific, but are also not specific to the object file
1416    format.  This file is probably the best place to define them, but
1417    they are not currently supported: .asm0, .endr, .lab, .struct.  */
1418
1419 static const pseudo_typeS mips_pseudo_table[] =
1420 {
1421   /* MIPS specific pseudo-ops.  */
1422   {"option", s_option, 0},
1423   {"set", s_mipsset, 0},
1424   {"rdata", s_change_sec, 'r'},
1425   {"sdata", s_change_sec, 's'},
1426   {"livereg", s_ignore, 0},
1427   {"abicalls", s_abicalls, 0},
1428   {"cpload", s_cpload, 0},
1429   {"cpsetup", s_cpsetup, 0},
1430   {"cplocal", s_cplocal, 0},
1431   {"cprestore", s_cprestore, 0},
1432   {"cpreturn", s_cpreturn, 0},
1433   {"dtprelword", s_dtprelword, 0},
1434   {"dtpreldword", s_dtpreldword, 0},
1435   {"gpvalue", s_gpvalue, 0},
1436   {"gpword", s_gpword, 0},
1437   {"gpdword", s_gpdword, 0},
1438   {"cpadd", s_cpadd, 0},
1439   {"insn", s_insn, 0},
1440
1441   /* Relatively generic pseudo-ops that happen to be used on MIPS
1442      chips.  */
1443   {"asciiz", stringer, 8 + 1},
1444   {"bss", s_change_sec, 'b'},
1445   {"err", s_err, 0},
1446   {"half", s_cons, 1},
1447   {"dword", s_cons, 3},
1448   {"weakext", s_mips_weakext, 0},
1449   {"origin", s_org, 0},
1450   {"repeat", s_rept, 0},
1451
1452   /* For MIPS this is non-standard, but we define it for consistency.  */
1453   {"sbss", s_change_sec, 'B'},
1454
1455   /* These pseudo-ops are defined in read.c, but must be overridden
1456      here for one reason or another.  */
1457   {"align", s_align, 0},
1458   {"byte", s_cons, 0},
1459   {"data", s_change_sec, 'd'},
1460   {"double", s_float_cons, 'd'},
1461   {"float", s_float_cons, 'f'},
1462   {"globl", s_mips_globl, 0},
1463   {"global", s_mips_globl, 0},
1464   {"hword", s_cons, 1},
1465   {"int", s_cons, 2},
1466   {"long", s_cons, 2},
1467   {"octa", s_cons, 4},
1468   {"quad", s_cons, 3},
1469   {"section", s_change_section, 0},
1470   {"short", s_cons, 1},
1471   {"single", s_float_cons, 'f'},
1472   {"stabn", s_mips_stab, 'n'},
1473   {"text", s_change_sec, 't'},
1474   {"word", s_cons, 2},
1475
1476   { "extern", ecoff_directive_extern, 0},
1477
1478   { NULL, NULL, 0 },
1479 };
1480
1481 static const pseudo_typeS mips_nonecoff_pseudo_table[] =
1482 {
1483   /* These pseudo-ops should be defined by the object file format.
1484      However, a.out doesn't support them, so we have versions here.  */
1485   {"aent", s_mips_ent, 1},
1486   {"bgnb", s_ignore, 0},
1487   {"end", s_mips_end, 0},
1488   {"endb", s_ignore, 0},
1489   {"ent", s_mips_ent, 0},
1490   {"file", s_mips_file, 0},
1491   {"fmask", s_mips_mask, 'F'},
1492   {"frame", s_mips_frame, 0},
1493   {"loc", s_mips_loc, 0},
1494   {"mask", s_mips_mask, 'R'},
1495   {"verstamp", s_ignore, 0},
1496   { NULL, NULL, 0 },
1497 };
1498
1499 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
1500    purpose of the `.dc.a' internal pseudo-op.  */
1501
1502 int
1503 mips_address_bytes (void)
1504 {
1505   return HAVE_64BIT_ADDRESSES ? 8 : 4;
1506 }
1507
1508 extern void pop_insert (const pseudo_typeS *);
1509
1510 void
1511 mips_pop_insert (void)
1512 {
1513   pop_insert (mips_pseudo_table);
1514   if (! ECOFF_DEBUGGING)
1515     pop_insert (mips_nonecoff_pseudo_table);
1516 }
1517 \f
1518 /* Symbols labelling the current insn.  */
1519
1520 struct insn_label_list
1521 {
1522   struct insn_label_list *next;
1523   symbolS *label;
1524 };
1525
1526 static struct insn_label_list *free_insn_labels;
1527 #define label_list tc_segment_info_data.labels
1528
1529 static void mips_clear_insn_labels (void);
1530 static void mips_mark_labels (void);
1531 static void mips_compressed_mark_labels (void);
1532
1533 static inline void
1534 mips_clear_insn_labels (void)
1535 {
1536   register struct insn_label_list **pl;
1537   segment_info_type *si;
1538
1539   if (now_seg)
1540     {
1541       for (pl = &free_insn_labels; *pl != NULL; pl = &(*pl)->next)
1542         ;
1543       
1544       si = seg_info (now_seg);
1545       *pl = si->label_list;
1546       si->label_list = NULL;
1547     }
1548 }
1549
1550 /* Mark instruction labels in MIPS16/microMIPS mode.  */
1551
1552 static inline void
1553 mips_mark_labels (void)
1554 {
1555   if (HAVE_CODE_COMPRESSION)
1556     mips_compressed_mark_labels ();
1557 }
1558 \f
1559 static char *expr_end;
1560
1561 /* Expressions which appear in instructions.  These are set by
1562    mips_ip.  */
1563
1564 static expressionS imm_expr;
1565 static expressionS imm2_expr;
1566 static expressionS offset_expr;
1567
1568 /* Relocs associated with imm_expr and offset_expr.  */
1569
1570 static bfd_reloc_code_real_type imm_reloc[3]
1571   = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
1572 static bfd_reloc_code_real_type offset_reloc[3]
1573   = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
1574
1575 /* This is set to the resulting size of the instruction to be produced
1576    by mips16_ip if an explicit extension is used or by mips_ip if an
1577    explicit size is supplied.  */
1578
1579 static unsigned int forced_insn_length;
1580
1581 #ifdef OBJ_ELF
1582 /* The pdr segment for per procedure frame/regmask info.  Not used for
1583    ECOFF debugging.  */
1584
1585 static segT pdr_seg;
1586 #endif
1587
1588 /* The default target format to use.  */
1589
1590 #if defined (TE_FreeBSD)
1591 #define ELF_TARGET(PREFIX, ENDIAN) PREFIX "trad" ENDIAN "mips-freebsd"
1592 #elif defined (TE_TMIPS)
1593 #define ELF_TARGET(PREFIX, ENDIAN) PREFIX "trad" ENDIAN "mips"
1594 #else
1595 #define ELF_TARGET(PREFIX, ENDIAN) PREFIX ENDIAN "mips"
1596 #endif
1597
1598 const char *
1599 mips_target_format (void)
1600 {
1601   switch (OUTPUT_FLAVOR)
1602     {
1603     case bfd_target_ecoff_flavour:
1604       return target_big_endian ? "ecoff-bigmips" : ECOFF_LITTLE_FORMAT;
1605     case bfd_target_coff_flavour:
1606       return "pe-mips";
1607     case bfd_target_elf_flavour:
1608 #ifdef TE_VXWORKS
1609       if (!HAVE_64BIT_OBJECTS && !HAVE_NEWABI)
1610         return (target_big_endian
1611                 ? "elf32-bigmips-vxworks"
1612                 : "elf32-littlemips-vxworks");
1613 #endif
1614       return (target_big_endian
1615               ? (HAVE_64BIT_OBJECTS
1616                  ? ELF_TARGET ("elf64-", "big")
1617                  : (HAVE_NEWABI
1618                     ? ELF_TARGET ("elf32-n", "big")
1619                     : ELF_TARGET ("elf32-", "big")))
1620               : (HAVE_64BIT_OBJECTS
1621                  ? ELF_TARGET ("elf64-", "little")
1622                  : (HAVE_NEWABI
1623                     ? ELF_TARGET ("elf32-n", "little")
1624                     : ELF_TARGET ("elf32-", "little"))));
1625     default:
1626       abort ();
1627       return NULL;
1628     }
1629 }
1630
1631 /* Return the length of a microMIPS instruction in bytes.  If bits of
1632    the mask beyond the low 16 are 0, then it is a 16-bit instruction.
1633    Otherwise assume a 32-bit instruction; 48-bit instructions (0x1f
1634    major opcode) will require further modifications to the opcode
1635    table.  */
1636
1637 static inline unsigned int
1638 micromips_insn_length (const struct mips_opcode *mo)
1639 {
1640   return (mo->mask >> 16) == 0 ? 2 : 4;
1641 }
1642
1643 /* Return the length of instruction INSN.  */
1644
1645 static inline unsigned int
1646 insn_length (const struct mips_cl_insn *insn)
1647 {
1648   if (mips_opts.micromips)
1649     return micromips_insn_length (insn->insn_mo);
1650   else if (mips_opts.mips16)
1651     return insn->mips16_absolute_jump_p || insn->use_extend ? 4 : 2;
1652   else
1653     return 4;
1654 }
1655
1656 /* Initialise INSN from opcode entry MO.  Leave its position unspecified.  */
1657
1658 static void
1659 create_insn (struct mips_cl_insn *insn, const struct mips_opcode *mo)
1660 {
1661   size_t i;
1662
1663   insn->insn_mo = mo;
1664   insn->use_extend = FALSE;
1665   insn->extend = 0;
1666   insn->insn_opcode = mo->match;
1667   insn->frag = NULL;
1668   insn->where = 0;
1669   for (i = 0; i < ARRAY_SIZE (insn->fixp); i++)
1670     insn->fixp[i] = NULL;
1671   insn->fixed_p = (mips_opts.noreorder > 0);
1672   insn->noreorder_p = (mips_opts.noreorder > 0);
1673   insn->mips16_absolute_jump_p = 0;
1674   insn->complete_p = 0;
1675 }
1676
1677 /* Record the current MIPS16/microMIPS mode in now_seg.  */
1678
1679 static void
1680 mips_record_compressed_mode (void)
1681 {
1682   segment_info_type *si;
1683
1684   si = seg_info (now_seg);
1685   if (si->tc_segment_info_data.mips16 != mips_opts.mips16)
1686     si->tc_segment_info_data.mips16 = mips_opts.mips16;
1687   if (si->tc_segment_info_data.micromips != mips_opts.micromips)
1688     si->tc_segment_info_data.micromips = mips_opts.micromips;
1689 }
1690
1691 /* Install INSN at the location specified by its "frag" and "where" fields.  */
1692
1693 static void
1694 install_insn (const struct mips_cl_insn *insn)
1695 {
1696   char *f = insn->frag->fr_literal + insn->where;
1697   if (!HAVE_CODE_COMPRESSION)
1698     md_number_to_chars (f, insn->insn_opcode, 4);
1699   else if (mips_opts.micromips)
1700     {
1701       unsigned int length = insn_length (insn);
1702       if (length == 2)
1703         md_number_to_chars (f, insn->insn_opcode, 2);
1704       else if (length == 4)
1705         {
1706           md_number_to_chars (f, insn->insn_opcode >> 16, 2);
1707           f += 2;
1708           md_number_to_chars (f, insn->insn_opcode & 0xffff, 2);
1709         }
1710       else
1711         as_bad (_("48-bit microMIPS instructions are not supported"));
1712     }
1713   else if (insn->mips16_absolute_jump_p)
1714     {
1715       md_number_to_chars (f, insn->insn_opcode >> 16, 2);
1716       md_number_to_chars (f + 2, insn->insn_opcode & 0xffff, 2);
1717     }
1718   else
1719     {
1720       if (insn->use_extend)
1721         {
1722           md_number_to_chars (f, 0xf000 | insn->extend, 2);
1723           f += 2;
1724         }
1725       md_number_to_chars (f, insn->insn_opcode, 2);
1726     }
1727   mips_record_compressed_mode ();
1728 }
1729
1730 /* Move INSN to offset WHERE in FRAG.  Adjust the fixups accordingly
1731    and install the opcode in the new location.  */
1732
1733 static void
1734 move_insn (struct mips_cl_insn *insn, fragS *frag, long where)
1735 {
1736   size_t i;
1737
1738   insn->frag = frag;
1739   insn->where = where;
1740   for (i = 0; i < ARRAY_SIZE (insn->fixp); i++)
1741     if (insn->fixp[i] != NULL)
1742       {
1743         insn->fixp[i]->fx_frag = frag;
1744         insn->fixp[i]->fx_where = where;
1745       }
1746   install_insn (insn);
1747 }
1748
1749 /* Add INSN to the end of the output.  */
1750
1751 static void
1752 add_fixed_insn (struct mips_cl_insn *insn)
1753 {
1754   char *f = frag_more (insn_length (insn));
1755   move_insn (insn, frag_now, f - frag_now->fr_literal);
1756 }
1757
1758 /* Start a variant frag and move INSN to the start of the variant part,
1759    marking it as fixed.  The other arguments are as for frag_var.  */
1760
1761 static void
1762 add_relaxed_insn (struct mips_cl_insn *insn, int max_chars, int var,
1763                   relax_substateT subtype, symbolS *symbol, offsetT offset)
1764 {
1765   frag_grow (max_chars);
1766   move_insn (insn, frag_now, frag_more (0) - frag_now->fr_literal);
1767   insn->fixed_p = 1;
1768   frag_var (rs_machine_dependent, max_chars, var,
1769             subtype, symbol, offset, NULL);
1770 }
1771
1772 /* Insert N copies of INSN into the history buffer, starting at
1773    position FIRST.  Neither FIRST nor N need to be clipped.  */
1774
1775 static void
1776 insert_into_history (unsigned int first, unsigned int n,
1777                      const struct mips_cl_insn *insn)
1778 {
1779   if (mips_relax.sequence != 2)
1780     {
1781       unsigned int i;
1782
1783       for (i = ARRAY_SIZE (history); i-- > first;)
1784         if (i >= first + n)
1785           history[i] = history[i - n];
1786         else
1787           history[i] = *insn;
1788     }
1789 }
1790
1791 /* Initialize vr4120_conflicts.  There is a bit of duplication here:
1792    the idea is to make it obvious at a glance that each errata is
1793    included.  */
1794
1795 static void
1796 init_vr4120_conflicts (void)
1797 {
1798 #define CONFLICT(FIRST, SECOND) \
1799     vr4120_conflicts[FIX_VR4120_##FIRST] |= 1 << FIX_VR4120_##SECOND
1800
1801   /* Errata 21 - [D]DIV[U] after [D]MACC */
1802   CONFLICT (MACC, DIV);
1803   CONFLICT (DMACC, DIV);
1804
1805   /* Errata 23 - Continuous DMULT[U]/DMACC instructions.  */
1806   CONFLICT (DMULT, DMULT);
1807   CONFLICT (DMULT, DMACC);
1808   CONFLICT (DMACC, DMULT);
1809   CONFLICT (DMACC, DMACC);
1810
1811   /* Errata 24 - MT{LO,HI} after [D]MACC */
1812   CONFLICT (MACC, MTHILO);
1813   CONFLICT (DMACC, MTHILO);
1814
1815   /* VR4181A errata MD(1): "If a MULT, MULTU, DMULT or DMULTU
1816      instruction is executed immediately after a MACC or DMACC
1817      instruction, the result of [either instruction] is incorrect."  */
1818   CONFLICT (MACC, MULT);
1819   CONFLICT (MACC, DMULT);
1820   CONFLICT (DMACC, MULT);
1821   CONFLICT (DMACC, DMULT);
1822
1823   /* VR4181A errata MD(4): "If a MACC or DMACC instruction is
1824      executed immediately after a DMULT, DMULTU, DIV, DIVU,
1825      DDIV or DDIVU instruction, the result of the MACC or
1826      DMACC instruction is incorrect.".  */
1827   CONFLICT (DMULT, MACC);
1828   CONFLICT (DMULT, DMACC);
1829   CONFLICT (DIV, MACC);
1830   CONFLICT (DIV, DMACC);
1831
1832 #undef CONFLICT
1833 }
1834
1835 struct regname {
1836   const char *name;
1837   unsigned int num;
1838 };
1839
1840 #define RTYPE_MASK      0x1ff00
1841 #define RTYPE_NUM       0x00100
1842 #define RTYPE_FPU       0x00200
1843 #define RTYPE_FCC       0x00400
1844 #define RTYPE_VEC       0x00800
1845 #define RTYPE_GP        0x01000
1846 #define RTYPE_CP0       0x02000
1847 #define RTYPE_PC        0x04000
1848 #define RTYPE_ACC       0x08000
1849 #define RTYPE_CCC       0x10000
1850 #define RNUM_MASK       0x000ff
1851 #define RWARN           0x80000
1852
1853 #define GENERIC_REGISTER_NUMBERS \
1854     {"$0",      RTYPE_NUM | 0},  \
1855     {"$1",      RTYPE_NUM | 1},  \
1856     {"$2",      RTYPE_NUM | 2},  \
1857     {"$3",      RTYPE_NUM | 3},  \
1858     {"$4",      RTYPE_NUM | 4},  \
1859     {"$5",      RTYPE_NUM | 5},  \
1860     {"$6",      RTYPE_NUM | 6},  \
1861     {"$7",      RTYPE_NUM | 7},  \
1862     {"$8",      RTYPE_NUM | 8},  \
1863     {"$9",      RTYPE_NUM | 9},  \
1864     {"$10",     RTYPE_NUM | 10}, \
1865     {"$11",     RTYPE_NUM | 11}, \
1866     {"$12",     RTYPE_NUM | 12}, \
1867     {"$13",     RTYPE_NUM | 13}, \
1868     {"$14",     RTYPE_NUM | 14}, \
1869     {"$15",     RTYPE_NUM | 15}, \
1870     {"$16",     RTYPE_NUM | 16}, \
1871     {"$17",     RTYPE_NUM | 17}, \
1872     {"$18",     RTYPE_NUM | 18}, \
1873     {"$19",     RTYPE_NUM | 19}, \
1874     {"$20",     RTYPE_NUM | 20}, \
1875     {"$21",     RTYPE_NUM | 21}, \
1876     {"$22",     RTYPE_NUM | 22}, \
1877     {"$23",     RTYPE_NUM | 23}, \
1878     {"$24",     RTYPE_NUM | 24}, \
1879     {"$25",     RTYPE_NUM | 25}, \
1880     {"$26",     RTYPE_NUM | 26}, \
1881     {"$27",     RTYPE_NUM | 27}, \
1882     {"$28",     RTYPE_NUM | 28}, \
1883     {"$29",     RTYPE_NUM | 29}, \
1884     {"$30",     RTYPE_NUM | 30}, \
1885     {"$31",     RTYPE_NUM | 31} 
1886
1887 #define FPU_REGISTER_NAMES       \
1888     {"$f0",     RTYPE_FPU | 0},  \
1889     {"$f1",     RTYPE_FPU | 1},  \
1890     {"$f2",     RTYPE_FPU | 2},  \
1891     {"$f3",     RTYPE_FPU | 3},  \
1892     {"$f4",     RTYPE_FPU | 4},  \
1893     {"$f5",     RTYPE_FPU | 5},  \
1894     {"$f6",     RTYPE_FPU | 6},  \
1895     {"$f7",     RTYPE_FPU | 7},  \
1896     {"$f8",     RTYPE_FPU | 8},  \
1897     {"$f9",     RTYPE_FPU | 9},  \
1898     {"$f10",    RTYPE_FPU | 10}, \
1899     {"$f11",    RTYPE_FPU | 11}, \
1900     {"$f12",    RTYPE_FPU | 12}, \
1901     {"$f13",    RTYPE_FPU | 13}, \
1902     {"$f14",    RTYPE_FPU | 14}, \
1903     {"$f15",    RTYPE_FPU | 15}, \
1904     {"$f16",    RTYPE_FPU | 16}, \
1905     {"$f17",    RTYPE_FPU | 17}, \
1906     {"$f18",    RTYPE_FPU | 18}, \
1907     {"$f19",    RTYPE_FPU | 19}, \
1908     {"$f20",    RTYPE_FPU | 20}, \
1909     {"$f21",    RTYPE_FPU | 21}, \
1910     {"$f22",    RTYPE_FPU | 22}, \
1911     {"$f23",    RTYPE_FPU | 23}, \
1912     {"$f24",    RTYPE_FPU | 24}, \
1913     {"$f25",    RTYPE_FPU | 25}, \
1914     {"$f26",    RTYPE_FPU | 26}, \
1915     {"$f27",    RTYPE_FPU | 27}, \
1916     {"$f28",    RTYPE_FPU | 28}, \
1917     {"$f29",    RTYPE_FPU | 29}, \
1918     {"$f30",    RTYPE_FPU | 30}, \
1919     {"$f31",    RTYPE_FPU | 31}
1920
1921 #define FPU_CONDITION_CODE_NAMES \
1922     {"$fcc0",   RTYPE_FCC | 0},  \
1923     {"$fcc1",   RTYPE_FCC | 1},  \
1924     {"$fcc2",   RTYPE_FCC | 2},  \
1925     {"$fcc3",   RTYPE_FCC | 3},  \
1926     {"$fcc4",   RTYPE_FCC | 4},  \
1927     {"$fcc5",   RTYPE_FCC | 5},  \
1928     {"$fcc6",   RTYPE_FCC | 6},  \
1929     {"$fcc7",   RTYPE_FCC | 7}
1930
1931 #define COPROC_CONDITION_CODE_NAMES         \
1932     {"$cc0",    RTYPE_FCC | RTYPE_CCC | 0}, \
1933     {"$cc1",    RTYPE_FCC | RTYPE_CCC | 1}, \
1934     {"$cc2",    RTYPE_FCC | RTYPE_CCC | 2}, \
1935     {"$cc3",    RTYPE_FCC | RTYPE_CCC | 3}, \
1936     {"$cc4",    RTYPE_FCC | RTYPE_CCC | 4}, \
1937     {"$cc5",    RTYPE_FCC | RTYPE_CCC | 5}, \
1938     {"$cc6",    RTYPE_FCC | RTYPE_CCC | 6}, \
1939     {"$cc7",    RTYPE_FCC | RTYPE_CCC | 7}
1940
1941 #define N32N64_SYMBOLIC_REGISTER_NAMES \
1942     {"$a4",     RTYPE_GP | 8},  \
1943     {"$a5",     RTYPE_GP | 9},  \
1944     {"$a6",     RTYPE_GP | 10}, \
1945     {"$a7",     RTYPE_GP | 11}, \
1946     {"$ta0",    RTYPE_GP | 8},  /* alias for $a4 */ \
1947     {"$ta1",    RTYPE_GP | 9},  /* alias for $a5 */ \
1948     {"$ta2",    RTYPE_GP | 10}, /* alias for $a6 */ \
1949     {"$ta3",    RTYPE_GP | 11}, /* alias for $a7 */ \
1950     {"$t0",     RTYPE_GP | 12}, \
1951     {"$t1",     RTYPE_GP | 13}, \
1952     {"$t2",     RTYPE_GP | 14}, \
1953     {"$t3",     RTYPE_GP | 15}
1954
1955 #define O32_SYMBOLIC_REGISTER_NAMES \
1956     {"$t0",     RTYPE_GP | 8},  \
1957     {"$t1",     RTYPE_GP | 9},  \
1958     {"$t2",     RTYPE_GP | 10}, \
1959     {"$t3",     RTYPE_GP | 11}, \
1960     {"$t4",     RTYPE_GP | 12}, \
1961     {"$t5",     RTYPE_GP | 13}, \
1962     {"$t6",     RTYPE_GP | 14}, \
1963     {"$t7",     RTYPE_GP | 15}, \
1964     {"$ta0",    RTYPE_GP | 12}, /* alias for $t4 */ \
1965     {"$ta1",    RTYPE_GP | 13}, /* alias for $t5 */ \
1966     {"$ta2",    RTYPE_GP | 14}, /* alias for $t6 */ \
1967     {"$ta3",    RTYPE_GP | 15}  /* alias for $t7 */ 
1968
1969 /* Remaining symbolic register names */
1970 #define SYMBOLIC_REGISTER_NAMES \
1971     {"$zero",   RTYPE_GP | 0},  \
1972     {"$at",     RTYPE_GP | 1},  \
1973     {"$AT",     RTYPE_GP | 1},  \
1974     {"$v0",     RTYPE_GP | 2},  \
1975     {"$v1",     RTYPE_GP | 3},  \
1976     {"$a0",     RTYPE_GP | 4},  \
1977     {"$a1",     RTYPE_GP | 5},  \
1978     {"$a2",     RTYPE_GP | 6},  \
1979     {"$a3",     RTYPE_GP | 7},  \
1980     {"$s0",     RTYPE_GP | 16}, \
1981     {"$s1",     RTYPE_GP | 17}, \
1982     {"$s2",     RTYPE_GP | 18}, \
1983     {"$s3",     RTYPE_GP | 19}, \
1984     {"$s4",     RTYPE_GP | 20}, \
1985     {"$s5",     RTYPE_GP | 21}, \
1986     {"$s6",     RTYPE_GP | 22}, \
1987     {"$s7",     RTYPE_GP | 23}, \
1988     {"$t8",     RTYPE_GP | 24}, \
1989     {"$t9",     RTYPE_GP | 25}, \
1990     {"$k0",     RTYPE_GP | 26}, \
1991     {"$kt0",    RTYPE_GP | 26}, \
1992     {"$k1",     RTYPE_GP | 27}, \
1993     {"$kt1",    RTYPE_GP | 27}, \
1994     {"$gp",     RTYPE_GP | 28}, \
1995     {"$sp",     RTYPE_GP | 29}, \
1996     {"$s8",     RTYPE_GP | 30}, \
1997     {"$fp",     RTYPE_GP | 30}, \
1998     {"$ra",     RTYPE_GP | 31}
1999
2000 #define MIPS16_SPECIAL_REGISTER_NAMES \
2001     {"$pc",     RTYPE_PC | 0}
2002
2003 #define MDMX_VECTOR_REGISTER_NAMES \
2004     /* {"$v0",  RTYPE_VEC | 0},  clash with REG 2 above */ \
2005     /* {"$v1",  RTYPE_VEC | 1},  clash with REG 3 above */ \
2006     {"$v2",     RTYPE_VEC | 2},  \
2007     {"$v3",     RTYPE_VEC | 3},  \
2008     {"$v4",     RTYPE_VEC | 4},  \
2009     {"$v5",     RTYPE_VEC | 5},  \
2010     {"$v6",     RTYPE_VEC | 6},  \
2011     {"$v7",     RTYPE_VEC | 7},  \
2012     {"$v8",     RTYPE_VEC | 8},  \
2013     {"$v9",     RTYPE_VEC | 9},  \
2014     {"$v10",    RTYPE_VEC | 10}, \
2015     {"$v11",    RTYPE_VEC | 11}, \
2016     {"$v12",    RTYPE_VEC | 12}, \
2017     {"$v13",    RTYPE_VEC | 13}, \
2018     {"$v14",    RTYPE_VEC | 14}, \
2019     {"$v15",    RTYPE_VEC | 15}, \
2020     {"$v16",    RTYPE_VEC | 16}, \
2021     {"$v17",    RTYPE_VEC | 17}, \
2022     {"$v18",    RTYPE_VEC | 18}, \
2023     {"$v19",    RTYPE_VEC | 19}, \
2024     {"$v20",    RTYPE_VEC | 20}, \
2025     {"$v21",    RTYPE_VEC | 21}, \
2026     {"$v22",    RTYPE_VEC | 22}, \
2027     {"$v23",    RTYPE_VEC | 23}, \
2028     {"$v24",    RTYPE_VEC | 24}, \
2029     {"$v25",    RTYPE_VEC | 25}, \
2030     {"$v26",    RTYPE_VEC | 26}, \
2031     {"$v27",    RTYPE_VEC | 27}, \
2032     {"$v28",    RTYPE_VEC | 28}, \
2033     {"$v29",    RTYPE_VEC | 29}, \
2034     {"$v30",    RTYPE_VEC | 30}, \
2035     {"$v31",    RTYPE_VEC | 31}
2036
2037 #define MIPS_DSP_ACCUMULATOR_NAMES \
2038     {"$ac0",    RTYPE_ACC | 0}, \
2039     {"$ac1",    RTYPE_ACC | 1}, \
2040     {"$ac2",    RTYPE_ACC | 2}, \
2041     {"$ac3",    RTYPE_ACC | 3}
2042
2043 static const struct regname reg_names[] = {
2044   GENERIC_REGISTER_NUMBERS,
2045   FPU_REGISTER_NAMES,
2046   FPU_CONDITION_CODE_NAMES,
2047   COPROC_CONDITION_CODE_NAMES,
2048
2049   /* The $txx registers depends on the abi,
2050      these will be added later into the symbol table from
2051      one of the tables below once mips_abi is set after 
2052      parsing of arguments from the command line. */
2053   SYMBOLIC_REGISTER_NAMES,
2054
2055   MIPS16_SPECIAL_REGISTER_NAMES,
2056   MDMX_VECTOR_REGISTER_NAMES,
2057   MIPS_DSP_ACCUMULATOR_NAMES,
2058   {0, 0}
2059 };
2060
2061 static const struct regname reg_names_o32[] = {
2062   O32_SYMBOLIC_REGISTER_NAMES,
2063   {0, 0}
2064 };
2065
2066 static const struct regname reg_names_n32n64[] = {
2067   N32N64_SYMBOLIC_REGISTER_NAMES,
2068   {0, 0}
2069 };
2070
2071 /* Check if S points at a valid register specifier according to TYPES.
2072    If so, then return 1, advance S to consume the specifier and store
2073    the register's number in REGNOP, otherwise return 0.  */
2074
2075 static int
2076 reg_lookup (char **s, unsigned int types, unsigned int *regnop)
2077 {
2078   symbolS *symbolP;
2079   char *e;
2080   char save_c;
2081   int reg = -1;
2082
2083   /* Find end of name.  */
2084   e = *s;
2085   if (is_name_beginner (*e))
2086     ++e;
2087   while (is_part_of_name (*e))
2088     ++e;
2089
2090   /* Terminate name.  */
2091   save_c = *e;
2092   *e = '\0';
2093
2094   /* Look for a register symbol.  */
2095   if ((symbolP = symbol_find (*s)) && S_GET_SEGMENT (symbolP) == reg_section)
2096     {
2097       int r = S_GET_VALUE (symbolP);
2098       if (r & types)
2099         reg = r & RNUM_MASK;
2100       else if ((types & RTYPE_VEC) && (r & ~1) == (RTYPE_GP | 2))
2101         /* Convert GP reg $v0/1 to MDMX reg $v0/1!  */
2102         reg = (r & RNUM_MASK) - 2;
2103     }
2104   /* Else see if this is a register defined in an itbl entry.  */
2105   else if ((types & RTYPE_GP) && itbl_have_entries)
2106     {
2107       char *n = *s;
2108       unsigned long r;
2109
2110       if (*n == '$')
2111         ++n;
2112       if (itbl_get_reg_val (n, &r))
2113         reg = r & RNUM_MASK;
2114     }
2115
2116   /* Advance to next token if a register was recognised.  */
2117   if (reg >= 0)
2118     *s = e;
2119   else if (types & RWARN)
2120     as_warn (_("Unrecognized register name `%s'"), *s);
2121
2122   *e = save_c;
2123   if (regnop)
2124     *regnop = reg;
2125   return reg >= 0;
2126 }
2127
2128 /* Check if S points at a valid register list according to TYPES.
2129    If so, then return 1, advance S to consume the list and store
2130    the registers present on the list as a bitmask of ones in REGLISTP,
2131    otherwise return 0.  A valid list comprises a comma-separated
2132    enumeration of valid single registers and/or dash-separated
2133    contiguous register ranges as determined by their numbers.
2134
2135    As a special exception if one of s0-s7 registers is specified as
2136    the range's lower delimiter and s8 (fp) is its upper one, then no
2137    registers whose numbers place them between s7 and s8 (i.e. $24-$29)
2138    are selected; they have to be listed separately if needed.  */
2139
2140 static int
2141 reglist_lookup (char **s, unsigned int types, unsigned int *reglistp)
2142 {
2143   unsigned int reglist = 0;
2144   unsigned int lastregno;
2145   bfd_boolean ok = TRUE;
2146   unsigned int regmask;
2147   char *s_endlist = *s;
2148   char *s_reset = *s;
2149   unsigned int regno;
2150
2151   while (reg_lookup (s, types, &regno))
2152     {
2153       lastregno = regno;
2154       if (**s == '-')
2155         {
2156           (*s)++;
2157           ok = reg_lookup (s, types, &lastregno);
2158           if (ok && lastregno < regno)
2159             ok = FALSE;
2160           if (!ok)
2161             break;
2162         }
2163
2164       if (lastregno == FP && regno >= S0 && regno <= S7)
2165         {
2166           lastregno = S7;
2167           reglist |= 1 << FP;
2168         }
2169       regmask = 1 << lastregno;
2170       regmask = (regmask << 1) - 1;
2171       regmask ^= (1 << regno) - 1;
2172       reglist |= regmask;
2173
2174       s_endlist = *s;
2175       if (**s != ',')
2176         break;
2177       (*s)++;
2178     }
2179
2180   if (ok)
2181     *s = s_endlist;
2182   else
2183     *s = s_reset;
2184   if (reglistp)
2185     *reglistp = reglist;
2186   return ok && reglist != 0;
2187 }
2188
2189 /* Return TRUE if opcode MO is valid on the currently selected ISA and
2190    architecture.  Use is_opcode_valid_16 for MIPS16 opcodes.  */
2191
2192 static bfd_boolean
2193 is_opcode_valid (const struct mips_opcode *mo)
2194 {
2195   int isa = mips_opts.isa;
2196   int fp_s, fp_d;
2197
2198   if (mips_opts.ase_mdmx)
2199     isa |= INSN_MDMX;
2200   if (mips_opts.ase_dsp)
2201     isa |= INSN_DSP;
2202   if (mips_opts.ase_dsp && ISA_SUPPORTS_DSP64_ASE)
2203     isa |= INSN_DSP64;
2204   if (mips_opts.ase_dspr2)
2205     isa |= INSN_DSPR2;
2206   if (mips_opts.ase_mt)
2207     isa |= INSN_MT;
2208   if (mips_opts.ase_mips3d)
2209     isa |= INSN_MIPS3D;
2210   if (mips_opts.ase_smartmips)
2211     isa |= INSN_SMARTMIPS;
2212   if (mips_opts.ase_mcu)
2213     isa |= INSN_MCU;
2214
2215   /* Don't accept instructions based on the ISA if the CPU does not implement
2216      all the coprocessor insns. */
2217   if (NO_ISA_COP (mips_opts.arch)
2218       && COP_INSN (mo->pinfo))
2219     isa = 0;
2220
2221   if (!OPCODE_IS_MEMBER (mo, isa, mips_opts.arch))
2222     return FALSE;
2223
2224   /* Check whether the instruction or macro requires single-precision or
2225      double-precision floating-point support.  Note that this information is
2226      stored differently in the opcode table for insns and macros.  */
2227   if (mo->pinfo == INSN_MACRO)
2228     {
2229       fp_s = mo->pinfo2 & INSN2_M_FP_S;
2230       fp_d = mo->pinfo2 & INSN2_M_FP_D;
2231     }
2232   else
2233     {
2234       fp_s = mo->pinfo & FP_S;
2235       fp_d = mo->pinfo & FP_D;
2236     }
2237
2238   if (fp_d && (mips_opts.soft_float || mips_opts.single_float))
2239     return FALSE;
2240
2241   if (fp_s && mips_opts.soft_float)
2242     return FALSE;
2243
2244   return TRUE;
2245 }
2246
2247 /* Return TRUE if the MIPS16 opcode MO is valid on the currently
2248    selected ISA and architecture.  */
2249
2250 static bfd_boolean
2251 is_opcode_valid_16 (const struct mips_opcode *mo)
2252 {
2253   return OPCODE_IS_MEMBER (mo, mips_opts.isa, mips_opts.arch) ? TRUE : FALSE;
2254 }
2255
2256 /* Return TRUE if the size of the microMIPS opcode MO matches one
2257    explicitly requested.  Always TRUE in the standard MIPS mode.  */
2258
2259 static bfd_boolean
2260 is_size_valid (const struct mips_opcode *mo)
2261 {
2262   if (!mips_opts.micromips)
2263     return TRUE;
2264
2265   if (!forced_insn_length)
2266     return TRUE;
2267   if (mo->pinfo == INSN_MACRO)
2268     return FALSE;
2269   return forced_insn_length == micromips_insn_length (mo);
2270 }
2271
2272 /* Return TRUE if the microMIPS opcode MO is valid for the delay slot
2273    of the preceding instruction.  Always TRUE in the standard MIPS mode.  */
2274
2275 static bfd_boolean
2276 is_delay_slot_valid (const struct mips_opcode *mo)
2277 {
2278   if (!mips_opts.micromips)
2279     return TRUE;
2280
2281   if (mo->pinfo == INSN_MACRO)
2282     return TRUE;
2283   if ((history[0].insn_mo->pinfo2 & INSN2_BRANCH_DELAY_32BIT) != 0
2284       && micromips_insn_length (mo) != 4)
2285     return FALSE;
2286   if ((history[0].insn_mo->pinfo2 & INSN2_BRANCH_DELAY_16BIT) != 0
2287       && micromips_insn_length (mo) != 2)
2288     return FALSE;
2289
2290   return TRUE;
2291 }
2292
2293 /* This function is called once, at assembler startup time.  It should set up
2294    all the tables, etc. that the MD part of the assembler will need.  */
2295
2296 void
2297 md_begin (void)
2298 {
2299   const char *retval = NULL;
2300   int i = 0;
2301   int broken = 0;
2302
2303   if (mips_pic != NO_PIC)
2304     {
2305       if (g_switch_seen && g_switch_value != 0)
2306         as_bad (_("-G may not be used in position-independent code"));
2307       g_switch_value = 0;
2308     }
2309
2310   if (! bfd_set_arch_mach (stdoutput, bfd_arch_mips, file_mips_arch))
2311     as_warn (_("Could not set architecture and machine"));
2312
2313   op_hash = hash_new ();
2314
2315   for (i = 0; i < NUMOPCODES;)
2316     {
2317       const char *name = mips_opcodes[i].name;
2318
2319       retval = hash_insert (op_hash, name, (void *) &mips_opcodes[i]);
2320       if (retval != NULL)
2321         {
2322           fprintf (stderr, _("internal error: can't hash `%s': %s\n"),
2323                    mips_opcodes[i].name, retval);
2324           /* Probably a memory allocation problem?  Give up now.  */
2325           as_fatal (_("Broken assembler.  No assembly attempted."));
2326         }
2327       do
2328         {
2329           if (mips_opcodes[i].pinfo != INSN_MACRO)
2330             {
2331               if (!validate_mips_insn (&mips_opcodes[i]))
2332                 broken = 1;
2333               if (nop_insn.insn_mo == NULL && strcmp (name, "nop") == 0)
2334                 {
2335                   create_insn (&nop_insn, mips_opcodes + i);
2336                   if (mips_fix_loongson2f_nop)
2337                     nop_insn.insn_opcode = LOONGSON2F_NOP_INSN;
2338                   nop_insn.fixed_p = 1;
2339                 }
2340             }
2341           ++i;
2342         }
2343       while ((i < NUMOPCODES) && !strcmp (mips_opcodes[i].name, name));
2344     }
2345
2346   mips16_op_hash = hash_new ();
2347
2348   i = 0;
2349   while (i < bfd_mips16_num_opcodes)
2350     {
2351       const char *name = mips16_opcodes[i].name;
2352
2353       retval = hash_insert (mips16_op_hash, name, (void *) &mips16_opcodes[i]);
2354       if (retval != NULL)
2355         as_fatal (_("internal: can't hash `%s': %s"),
2356                   mips16_opcodes[i].name, retval);
2357       do
2358         {
2359           if (mips16_opcodes[i].pinfo != INSN_MACRO
2360               && ((mips16_opcodes[i].match & mips16_opcodes[i].mask)
2361                   != mips16_opcodes[i].match))
2362             {
2363               fprintf (stderr, _("internal error: bad mips16 opcode: %s %s\n"),
2364                        mips16_opcodes[i].name, mips16_opcodes[i].args);
2365               broken = 1;
2366             }
2367           if (mips16_nop_insn.insn_mo == NULL && strcmp (name, "nop") == 0)
2368             {
2369               create_insn (&mips16_nop_insn, mips16_opcodes + i);
2370               mips16_nop_insn.fixed_p = 1;
2371             }
2372           ++i;
2373         }
2374       while (i < bfd_mips16_num_opcodes
2375              && strcmp (mips16_opcodes[i].name, name) == 0);
2376     }
2377
2378   micromips_op_hash = hash_new ();
2379
2380   i = 0;
2381   while (i < bfd_micromips_num_opcodes)
2382     {
2383       const char *name = micromips_opcodes[i].name;
2384
2385       retval = hash_insert (micromips_op_hash, name,
2386                             (void *) &micromips_opcodes[i]);
2387       if (retval != NULL)
2388         as_fatal (_("internal: can't hash `%s': %s"),
2389                   micromips_opcodes[i].name, retval);
2390       do
2391         if (micromips_opcodes[i].pinfo != INSN_MACRO)
2392           {
2393             struct mips_cl_insn *micromips_nop_insn;
2394
2395             if (!validate_micromips_insn (&micromips_opcodes[i]))
2396               broken = 1;
2397
2398             if (micromips_insn_length (micromips_opcodes + i) == 2)
2399               micromips_nop_insn = &micromips_nop16_insn;
2400             else if (micromips_insn_length (micromips_opcodes + i) == 4)
2401               micromips_nop_insn = &micromips_nop32_insn;
2402             else
2403               continue;
2404
2405             if (micromips_nop_insn->insn_mo == NULL
2406                 && strcmp (name, "nop") == 0)
2407               {
2408                 create_insn (micromips_nop_insn, micromips_opcodes + i);
2409                 micromips_nop_insn->fixed_p = 1;
2410               }
2411           }
2412       while (++i < bfd_micromips_num_opcodes
2413              && strcmp (micromips_opcodes[i].name, name) == 0);
2414     }
2415
2416   if (broken)
2417     as_fatal (_("Broken assembler.  No assembly attempted."));
2418
2419   /* We add all the general register names to the symbol table.  This
2420      helps us detect invalid uses of them.  */
2421   for (i = 0; reg_names[i].name; i++) 
2422     symbol_table_insert (symbol_new (reg_names[i].name, reg_section,
2423                                      reg_names[i].num, /* & RNUM_MASK, */
2424                                      &zero_address_frag));
2425   if (HAVE_NEWABI)
2426     for (i = 0; reg_names_n32n64[i].name; i++) 
2427       symbol_table_insert (symbol_new (reg_names_n32n64[i].name, reg_section,
2428                                        reg_names_n32n64[i].num, /* & RNUM_MASK, */
2429                                        &zero_address_frag));
2430   else
2431     for (i = 0; reg_names_o32[i].name; i++) 
2432       symbol_table_insert (symbol_new (reg_names_o32[i].name, reg_section,
2433                                        reg_names_o32[i].num, /* & RNUM_MASK, */
2434                                        &zero_address_frag));
2435
2436   mips_no_prev_insn ();
2437
2438   mips_gprmask = 0;
2439   mips_cprmask[0] = 0;
2440   mips_cprmask[1] = 0;
2441   mips_cprmask[2] = 0;
2442   mips_cprmask[3] = 0;
2443
2444   /* set the default alignment for the text section (2**2) */
2445   record_alignment (text_section, 2);
2446
2447   bfd_set_gp_size (stdoutput, g_switch_value);
2448
2449 #ifdef OBJ_ELF
2450   if (IS_ELF)
2451     {
2452       /* On a native system other than VxWorks, sections must be aligned
2453          to 16 byte boundaries.  When configured for an embedded ELF
2454          target, we don't bother.  */
2455       if (strncmp (TARGET_OS, "elf", 3) != 0
2456           && strncmp (TARGET_OS, "vxworks", 7) != 0)
2457         {
2458           (void) bfd_set_section_alignment (stdoutput, text_section, 4);
2459           (void) bfd_set_section_alignment (stdoutput, data_section, 4);
2460           (void) bfd_set_section_alignment (stdoutput, bss_section, 4);
2461         }
2462
2463       /* Create a .reginfo section for register masks and a .mdebug
2464          section for debugging information.  */
2465       {
2466         segT seg;
2467         subsegT subseg;
2468         flagword flags;
2469         segT sec;
2470
2471         seg = now_seg;
2472         subseg = now_subseg;
2473
2474         /* The ABI says this section should be loaded so that the
2475            running program can access it.  However, we don't load it
2476            if we are configured for an embedded target */
2477         flags = SEC_READONLY | SEC_DATA;
2478         if (strncmp (TARGET_OS, "elf", 3) != 0)
2479           flags |= SEC_ALLOC | SEC_LOAD;
2480
2481         if (mips_abi != N64_ABI)
2482           {
2483             sec = subseg_new (".reginfo", (subsegT) 0);
2484
2485             bfd_set_section_flags (stdoutput, sec, flags);
2486             bfd_set_section_alignment (stdoutput, sec, HAVE_NEWABI ? 3 : 2);
2487
2488             mips_regmask_frag = frag_more (sizeof (Elf32_External_RegInfo));
2489           }
2490         else
2491           {
2492             /* The 64-bit ABI uses a .MIPS.options section rather than
2493                .reginfo section.  */
2494             sec = subseg_new (".MIPS.options", (subsegT) 0);
2495             bfd_set_section_flags (stdoutput, sec, flags);
2496             bfd_set_section_alignment (stdoutput, sec, 3);
2497
2498             /* Set up the option header.  */
2499             {
2500               Elf_Internal_Options opthdr;
2501               char *f;
2502
2503               opthdr.kind = ODK_REGINFO;
2504               opthdr.size = (sizeof (Elf_External_Options)
2505                              + sizeof (Elf64_External_RegInfo));
2506               opthdr.section = 0;
2507               opthdr.info = 0;
2508               f = frag_more (sizeof (Elf_External_Options));
2509               bfd_mips_elf_swap_options_out (stdoutput, &opthdr,
2510                                              (Elf_External_Options *) f);
2511
2512               mips_regmask_frag = frag_more (sizeof (Elf64_External_RegInfo));
2513             }
2514           }
2515
2516         if (ECOFF_DEBUGGING)
2517           {
2518             sec = subseg_new (".mdebug", (subsegT) 0);
2519             (void) bfd_set_section_flags (stdoutput, sec,
2520                                           SEC_HAS_CONTENTS | SEC_READONLY);
2521             (void) bfd_set_section_alignment (stdoutput, sec, 2);
2522           }
2523         else if (mips_flag_pdr)
2524           {
2525             pdr_seg = subseg_new (".pdr", (subsegT) 0);
2526             (void) bfd_set_section_flags (stdoutput, pdr_seg,
2527                                           SEC_READONLY | SEC_RELOC
2528                                           | SEC_DEBUGGING);
2529             (void) bfd_set_section_alignment (stdoutput, pdr_seg, 2);
2530           }
2531
2532         subseg_set (seg, subseg);
2533       }
2534     }
2535 #endif /* OBJ_ELF */
2536
2537   if (! ECOFF_DEBUGGING)
2538     md_obj_begin ();
2539
2540   if (mips_fix_vr4120)
2541     init_vr4120_conflicts ();
2542 }
2543
2544 void
2545 md_mips_end (void)
2546 {
2547   mips_emit_delays ();
2548   if (! ECOFF_DEBUGGING)
2549     md_obj_end ();
2550 }
2551
2552 void
2553 md_assemble (char *str)
2554 {
2555   struct mips_cl_insn insn;
2556   bfd_reloc_code_real_type unused_reloc[3]
2557     = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
2558
2559   imm_expr.X_op = O_absent;
2560   imm2_expr.X_op = O_absent;
2561   offset_expr.X_op = O_absent;
2562   imm_reloc[0] = BFD_RELOC_UNUSED;
2563   imm_reloc[1] = BFD_RELOC_UNUSED;
2564   imm_reloc[2] = BFD_RELOC_UNUSED;
2565   offset_reloc[0] = BFD_RELOC_UNUSED;
2566   offset_reloc[1] = BFD_RELOC_UNUSED;
2567   offset_reloc[2] = BFD_RELOC_UNUSED;
2568
2569   if (mips_opts.mips16)
2570     mips16_ip (str, &insn);
2571   else
2572     {
2573       mips_ip (str, &insn);
2574       DBG ((_("returned from mips_ip(%s) insn_opcode = 0x%x\n"),
2575             str, insn.insn_opcode));
2576     }
2577
2578   if (insn_error)
2579     {
2580       as_bad ("%s `%s'", insn_error, str);
2581       return;
2582     }
2583
2584   if (insn.insn_mo->pinfo == INSN_MACRO)
2585     {
2586       macro_start ();
2587       if (mips_opts.mips16)
2588         mips16_macro (&insn);
2589       else
2590         macro (&insn);
2591       macro_end ();
2592     }
2593   else
2594     {
2595       if (imm_expr.X_op != O_absent)
2596         append_insn (&insn, &imm_expr, imm_reloc, FALSE);
2597       else if (offset_expr.X_op != O_absent)
2598         append_insn (&insn, &offset_expr, offset_reloc, FALSE);
2599       else
2600         append_insn (&insn, NULL, unused_reloc, FALSE);
2601     }
2602 }
2603
2604 /* Convenience functions for abstracting away the differences between
2605    MIPS16 and non-MIPS16 relocations.  */
2606
2607 static inline bfd_boolean
2608 mips16_reloc_p (bfd_reloc_code_real_type reloc)
2609 {
2610   switch (reloc)
2611     {
2612     case BFD_RELOC_MIPS16_JMP:
2613     case BFD_RELOC_MIPS16_GPREL:
2614     case BFD_RELOC_MIPS16_GOT16:
2615     case BFD_RELOC_MIPS16_CALL16:
2616     case BFD_RELOC_MIPS16_HI16_S:
2617     case BFD_RELOC_MIPS16_HI16:
2618     case BFD_RELOC_MIPS16_LO16:
2619       return TRUE;
2620
2621     default:
2622       return FALSE;
2623     }
2624 }
2625
2626 static inline bfd_boolean
2627 micromips_reloc_p (bfd_reloc_code_real_type reloc)
2628 {
2629   switch (reloc)
2630     {
2631     case BFD_RELOC_MICROMIPS_7_PCREL_S1:
2632     case BFD_RELOC_MICROMIPS_10_PCREL_S1:
2633     case BFD_RELOC_MICROMIPS_16_PCREL_S1:
2634     case BFD_RELOC_MICROMIPS_GPREL16:
2635     case BFD_RELOC_MICROMIPS_JMP:
2636     case BFD_RELOC_MICROMIPS_HI16:
2637     case BFD_RELOC_MICROMIPS_HI16_S:
2638     case BFD_RELOC_MICROMIPS_LO16:
2639     case BFD_RELOC_MICROMIPS_LITERAL:
2640     case BFD_RELOC_MICROMIPS_GOT16:
2641     case BFD_RELOC_MICROMIPS_CALL16:
2642     case BFD_RELOC_MICROMIPS_GOT_HI16:
2643     case BFD_RELOC_MICROMIPS_GOT_LO16:
2644     case BFD_RELOC_MICROMIPS_CALL_HI16:
2645     case BFD_RELOC_MICROMIPS_CALL_LO16:
2646     case BFD_RELOC_MICROMIPS_SUB:
2647     case BFD_RELOC_MICROMIPS_GOT_PAGE:
2648     case BFD_RELOC_MICROMIPS_GOT_OFST:
2649     case BFD_RELOC_MICROMIPS_GOT_DISP:
2650     case BFD_RELOC_MICROMIPS_HIGHEST:
2651     case BFD_RELOC_MICROMIPS_HIGHER:
2652     case BFD_RELOC_MICROMIPS_SCN_DISP:
2653     case BFD_RELOC_MICROMIPS_JALR:
2654       return TRUE;
2655
2656     default:
2657       return FALSE;
2658     }
2659 }
2660
2661 static inline bfd_boolean
2662 jmp_reloc_p (bfd_reloc_code_real_type reloc)
2663 {
2664   return reloc == BFD_RELOC_MIPS_JMP || reloc == BFD_RELOC_MICROMIPS_JMP;
2665 }
2666
2667 static inline bfd_boolean
2668 got16_reloc_p (bfd_reloc_code_real_type reloc)
2669 {
2670   return (reloc == BFD_RELOC_MIPS_GOT16 || reloc == BFD_RELOC_MIPS16_GOT16
2671           || reloc == BFD_RELOC_MICROMIPS_GOT16);
2672 }
2673
2674 static inline bfd_boolean
2675 hi16_reloc_p (bfd_reloc_code_real_type reloc)
2676 {
2677   return (reloc == BFD_RELOC_HI16_S || reloc == BFD_RELOC_MIPS16_HI16_S
2678           || reloc == BFD_RELOC_MICROMIPS_HI16_S);
2679 }
2680
2681 static inline bfd_boolean
2682 lo16_reloc_p (bfd_reloc_code_real_type reloc)
2683 {
2684   return (reloc == BFD_RELOC_LO16 || reloc == BFD_RELOC_MIPS16_LO16
2685           || reloc == BFD_RELOC_MICROMIPS_LO16);
2686 }
2687
2688 static inline bfd_boolean
2689 jalr_reloc_p (bfd_reloc_code_real_type reloc)
2690 {
2691   return reloc == BFD_RELOC_MIPS_JALR || reloc == BFD_RELOC_MICROMIPS_JALR;
2692 }
2693
2694 /* Return true if the given relocation might need a matching %lo().
2695    This is only "might" because SVR4 R_MIPS_GOT16 relocations only
2696    need a matching %lo() when applied to local symbols.  */
2697
2698 static inline bfd_boolean
2699 reloc_needs_lo_p (bfd_reloc_code_real_type reloc)
2700 {
2701   return (HAVE_IN_PLACE_ADDENDS
2702           && (hi16_reloc_p (reloc)
2703               /* VxWorks R_MIPS_GOT16 relocs never need a matching %lo();
2704                  all GOT16 relocations evaluate to "G".  */
2705               || (got16_reloc_p (reloc) && mips_pic != VXWORKS_PIC)));
2706 }
2707
2708 /* Return the type of %lo() reloc needed by RELOC, given that
2709    reloc_needs_lo_p.  */
2710
2711 static inline bfd_reloc_code_real_type
2712 matching_lo_reloc (bfd_reloc_code_real_type reloc)
2713 {
2714   return (mips16_reloc_p (reloc) ? BFD_RELOC_MIPS16_LO16
2715           : (micromips_reloc_p (reloc) ? BFD_RELOC_MICROMIPS_LO16
2716              : BFD_RELOC_LO16));
2717 }
2718
2719 /* Return true if the given fixup is followed by a matching R_MIPS_LO16
2720    relocation.  */
2721
2722 static inline bfd_boolean
2723 fixup_has_matching_lo_p (fixS *fixp)
2724 {
2725   return (fixp->fx_next != NULL
2726           && fixp->fx_next->fx_r_type == matching_lo_reloc (fixp->fx_r_type)
2727           && fixp->fx_addsy == fixp->fx_next->fx_addsy
2728           && fixp->fx_offset == fixp->fx_next->fx_offset);
2729 }
2730
2731 /* This function returns true if modifying a register requires a
2732    delay.  */
2733
2734 static int
2735 reg_needs_delay (unsigned int reg)
2736 {
2737   unsigned long prev_pinfo;
2738
2739   prev_pinfo = history[0].insn_mo->pinfo;
2740   if (! mips_opts.noreorder
2741       && (((prev_pinfo & INSN_LOAD_MEMORY_DELAY)
2742            && ! gpr_interlocks)
2743           || ((prev_pinfo & INSN_LOAD_COPROC_DELAY)
2744               && ! cop_interlocks)))
2745     {
2746       /* A load from a coprocessor or from memory.  All load delays
2747          delay the use of general register rt for one instruction.  */
2748       /* Itbl support may require additional care here.  */
2749       know (prev_pinfo & INSN_WRITE_GPR_T);
2750       if (reg == EXTRACT_OPERAND (mips_opts.micromips, RT, history[0]))
2751         return 1;
2752     }
2753
2754   return 0;
2755 }
2756
2757 /* Move all labels in insn_labels to the current insertion point.  */
2758
2759 static void
2760 mips_move_labels (void)
2761 {
2762   segment_info_type *si = seg_info (now_seg);
2763   struct insn_label_list *l;
2764   valueT val;
2765
2766   for (l = si->label_list; l != NULL; l = l->next)
2767     {
2768       gas_assert (S_GET_SEGMENT (l->label) == now_seg);
2769       symbol_set_frag (l->label, frag_now);
2770       val = (valueT) frag_now_fix ();
2771       /* MIPS16/microMIPS text labels are stored as odd.  */
2772       if (HAVE_CODE_COMPRESSION)
2773         ++val;
2774       S_SET_VALUE (l->label, val);
2775     }
2776 }
2777
2778 static bfd_boolean
2779 s_is_linkonce (symbolS *sym, segT from_seg)
2780 {
2781   bfd_boolean linkonce = FALSE;
2782   segT symseg = S_GET_SEGMENT (sym);
2783
2784   if (symseg != from_seg && !S_IS_LOCAL (sym))
2785     {
2786       if ((bfd_get_section_flags (stdoutput, symseg) & SEC_LINK_ONCE))
2787         linkonce = TRUE;
2788 #ifdef OBJ_ELF
2789       /* The GNU toolchain uses an extension for ELF: a section
2790          beginning with the magic string .gnu.linkonce is a
2791          linkonce section.  */
2792       if (strncmp (segment_name (symseg), ".gnu.linkonce",
2793                    sizeof ".gnu.linkonce" - 1) == 0)
2794         linkonce = TRUE;
2795 #endif
2796     }
2797   return linkonce;
2798 }
2799
2800 /* Mark instruction labels in MIPS16/microMIPS mode.  This permits the
2801    linker to handle them specially, such as generating jalx instructions
2802    when needed.  We also make them odd for the duration of the assembly,
2803    in order to generate the right sort of code.  We will make them even
2804    in the adjust_symtab routine, while leaving them marked.  This is
2805    convenient for the debugger and the disassembler.  The linker knows
2806    to make them odd again.  */
2807
2808 static void
2809 mips_compressed_mark_labels (void)
2810 {
2811   segment_info_type *si = seg_info (now_seg);
2812   struct insn_label_list *l;
2813
2814   gas_assert (HAVE_CODE_COMPRESSION);
2815
2816   for (l = si->label_list; l != NULL; l = l->next)
2817    {
2818       symbolS *label = l->label;
2819
2820 #if defined(OBJ_ELF) || defined(OBJ_MAYBE_ELF)
2821       if (IS_ELF)
2822         {
2823           if (mips_opts.mips16)
2824             S_SET_OTHER (label, ELF_ST_SET_MIPS16 (S_GET_OTHER (label)));
2825           else
2826             S_SET_OTHER (label, ELF_ST_SET_MICROMIPS (S_GET_OTHER (label)));
2827         }
2828 #endif
2829       if ((S_GET_VALUE (label) & 1) == 0
2830         /* Don't adjust the address if the label is global or weak, or
2831            in a link-once section, since we'll be emitting symbol reloc
2832            references to it which will be patched up by the linker, and
2833            the final value of the symbol may or may not be MIPS16/microMIPS.  */
2834           && ! S_IS_WEAK (label)
2835           && ! S_IS_EXTERNAL (label)
2836           && ! s_is_linkonce (label, now_seg))
2837         S_SET_VALUE (label, S_GET_VALUE (label) | 1);
2838     }
2839 }
2840
2841 /* End the current frag.  Make it a variant frag and record the
2842    relaxation info.  */
2843
2844 static void
2845 relax_close_frag (void)
2846 {
2847   mips_macro_warning.first_frag = frag_now;
2848   frag_var (rs_machine_dependent, 0, 0,
2849             RELAX_ENCODE (mips_relax.sizes[0], mips_relax.sizes[1]),
2850             mips_relax.symbol, 0, (char *) mips_relax.first_fixup);
2851
2852   memset (&mips_relax.sizes, 0, sizeof (mips_relax.sizes));
2853   mips_relax.first_fixup = 0;
2854 }
2855
2856 /* Start a new relaxation sequence whose expansion depends on SYMBOL.
2857    See the comment above RELAX_ENCODE for more details.  */
2858
2859 static void
2860 relax_start (symbolS *symbol)
2861 {
2862   gas_assert (mips_relax.sequence == 0);
2863   mips_relax.sequence = 1;
2864   mips_relax.symbol = symbol;
2865 }
2866
2867 /* Start generating the second version of a relaxable sequence.
2868    See the comment above RELAX_ENCODE for more details.  */
2869
2870 static void
2871 relax_switch (void)
2872 {
2873   gas_assert (mips_relax.sequence == 1);
2874   mips_relax.sequence = 2;
2875 }
2876
2877 /* End the current relaxable sequence.  */
2878
2879 static void
2880 relax_end (void)
2881 {
2882   gas_assert (mips_relax.sequence == 2);
2883   relax_close_frag ();
2884   mips_relax.sequence = 0;
2885 }
2886
2887 /* Return true if IP is a delayed branch or jump.  */
2888
2889 static inline bfd_boolean
2890 delayed_branch_p (const struct mips_cl_insn *ip)
2891 {
2892   return (ip->insn_mo->pinfo & (INSN_UNCOND_BRANCH_DELAY
2893                                 | INSN_COND_BRANCH_DELAY
2894                                 | INSN_COND_BRANCH_LIKELY)) != 0;
2895 }
2896
2897 /* Return true if IP is a compact branch or jump.  */
2898
2899 static inline bfd_boolean
2900 compact_branch_p (const struct mips_cl_insn *ip)
2901 {
2902   if (mips_opts.mips16)
2903     return (ip->insn_mo->pinfo & (MIPS16_INSN_UNCOND_BRANCH
2904                                   | MIPS16_INSN_COND_BRANCH)) != 0;
2905   else
2906     return (ip->insn_mo->pinfo2 & (INSN2_UNCOND_BRANCH
2907                                    | INSN2_COND_BRANCH)) != 0;
2908 }
2909
2910 /* Return true if IP is an unconditional branch or jump.  */
2911
2912 static inline bfd_boolean
2913 uncond_branch_p (const struct mips_cl_insn *ip)
2914 {
2915   return ((ip->insn_mo->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0
2916           || (mips_opts.mips16
2917               ? (ip->insn_mo->pinfo & MIPS16_INSN_UNCOND_BRANCH) != 0
2918               : (ip->insn_mo->pinfo2 & INSN2_UNCOND_BRANCH) != 0));
2919 }
2920
2921 /* Return true if IP is a branch-likely instruction.  */
2922
2923 static inline bfd_boolean
2924 branch_likely_p (const struct mips_cl_insn *ip)
2925 {
2926   return (ip->insn_mo->pinfo & INSN_COND_BRANCH_LIKELY) != 0;
2927 }
2928
2929 /* Return the type of nop that should be used to fill the delay slot
2930    of delayed branch IP.  */
2931
2932 static struct mips_cl_insn *
2933 get_delay_slot_nop (const struct mips_cl_insn *ip)
2934 {
2935   if (mips_opts.micromips
2936       && (ip->insn_mo->pinfo2 & INSN2_BRANCH_DELAY_32BIT))
2937     return &micromips_nop32_insn;
2938   return NOP_INSN;
2939 }
2940
2941 /* Return the mask of core registers that IP reads or writes.  */
2942
2943 static unsigned int
2944 gpr_mod_mask (const struct mips_cl_insn *ip)
2945 {
2946   unsigned long pinfo2;
2947   unsigned int mask;
2948
2949   mask = 0;
2950   pinfo2 = ip->insn_mo->pinfo2;
2951   if (mips_opts.micromips)
2952     {
2953       if (pinfo2 & INSN2_MOD_GPR_MD)
2954         mask |= 1 << micromips_to_32_reg_d_map[EXTRACT_OPERAND (1, MD, *ip)];
2955       if (pinfo2 & INSN2_MOD_GPR_MF)
2956         mask |= 1 << micromips_to_32_reg_f_map[EXTRACT_OPERAND (1, MF, *ip)];
2957       if (pinfo2 & INSN2_MOD_SP)
2958         mask |= 1 << SP;
2959     }
2960   return mask;
2961 }
2962
2963 /* Return the mask of core registers that IP reads.  */
2964
2965 static unsigned int
2966 gpr_read_mask (const struct mips_cl_insn *ip)
2967 {
2968   unsigned long pinfo, pinfo2;
2969   unsigned int mask;
2970
2971   mask = gpr_mod_mask (ip);
2972   pinfo = ip->insn_mo->pinfo;
2973   pinfo2 = ip->insn_mo->pinfo2;
2974   if (mips_opts.mips16)
2975     {
2976       if (pinfo & MIPS16_INSN_READ_X)
2977         mask |= 1 << mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RX, *ip)];
2978       if (pinfo & MIPS16_INSN_READ_Y)
2979         mask |= 1 << mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RY, *ip)];
2980       if (pinfo & MIPS16_INSN_READ_T)
2981         mask |= 1 << TREG;
2982       if (pinfo & MIPS16_INSN_READ_SP)
2983         mask |= 1 << SP;
2984       if (pinfo & MIPS16_INSN_READ_31)
2985         mask |= 1 << RA;
2986       if (pinfo & MIPS16_INSN_READ_Z)
2987         mask |= 1 << (mips16_to_32_reg_map
2988                       [MIPS16_EXTRACT_OPERAND (MOVE32Z, *ip)]);
2989       if (pinfo & MIPS16_INSN_READ_GPR_X)
2990         mask |= 1 << MIPS16_EXTRACT_OPERAND (REGR32, *ip);
2991     }
2992   else
2993     {
2994       if (pinfo2 & INSN2_READ_GPR_D)
2995         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RD, *ip);
2996       if (pinfo & INSN_READ_GPR_T)
2997         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RT, *ip);
2998       if (pinfo & INSN_READ_GPR_S)
2999         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RS, *ip);
3000       if (pinfo2 & INSN2_READ_GP)
3001         mask |= 1 << GP;
3002       if (pinfo2 & INSN2_READ_GPR_31)
3003         mask |= 1 << RA;
3004       if (pinfo2 & INSN2_READ_GPR_Z)
3005         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RZ, *ip);
3006     }
3007   if (mips_opts.micromips)
3008     {
3009       if (pinfo2 & INSN2_READ_GPR_MC)
3010         mask |= 1 << micromips_to_32_reg_c_map[EXTRACT_OPERAND (1, MC, *ip)];
3011       if (pinfo2 & INSN2_READ_GPR_ME)
3012         mask |= 1 << micromips_to_32_reg_e_map[EXTRACT_OPERAND (1, ME, *ip)];
3013       if (pinfo2 & INSN2_READ_GPR_MG)
3014         mask |= 1 << micromips_to_32_reg_g_map[EXTRACT_OPERAND (1, MG, *ip)];
3015       if (pinfo2 & INSN2_READ_GPR_MJ)
3016         mask |= 1 << EXTRACT_OPERAND (1, MJ, *ip);
3017       if (pinfo2 & INSN2_READ_GPR_MMN)
3018         {
3019           mask |= 1 << micromips_to_32_reg_m_map[EXTRACT_OPERAND (1, MM, *ip)];
3020           mask |= 1 << micromips_to_32_reg_n_map[EXTRACT_OPERAND (1, MN, *ip)];
3021         }
3022       if (pinfo2 & INSN2_READ_GPR_MP)
3023         mask |= 1 << EXTRACT_OPERAND (1, MP, *ip);
3024       if (pinfo2 & INSN2_READ_GPR_MQ)
3025         mask |= 1 << micromips_to_32_reg_q_map[EXTRACT_OPERAND (1, MQ, *ip)];
3026     }
3027   /* Don't include register 0.  */
3028   return mask & ~1;
3029 }
3030
3031 /* Return the mask of core registers that IP writes.  */
3032
3033 static unsigned int
3034 gpr_write_mask (const struct mips_cl_insn *ip)
3035 {
3036   unsigned long pinfo, pinfo2;
3037   unsigned int mask;
3038
3039   mask = gpr_mod_mask (ip);
3040   pinfo = ip->insn_mo->pinfo;
3041   pinfo2 = ip->insn_mo->pinfo2;
3042   if (mips_opts.mips16)
3043     {
3044       if (pinfo & MIPS16_INSN_WRITE_X)
3045         mask |= 1 << mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RX, *ip)];
3046       if (pinfo & MIPS16_INSN_WRITE_Y)
3047         mask |= 1 << mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RY, *ip)];
3048       if (pinfo & MIPS16_INSN_WRITE_Z)
3049         mask |= 1 << mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RZ, *ip)];
3050       if (pinfo & MIPS16_INSN_WRITE_T)
3051         mask |= 1 << TREG;
3052       if (pinfo & MIPS16_INSN_WRITE_SP)
3053         mask |= 1 << SP;
3054       if (pinfo & MIPS16_INSN_WRITE_31)
3055         mask |= 1 << RA;
3056       if (pinfo & MIPS16_INSN_WRITE_GPR_Y)
3057         mask |= 1 << MIPS16OP_EXTRACT_REG32R (ip->insn_opcode);
3058     }
3059   else
3060     {
3061       if (pinfo & INSN_WRITE_GPR_D)
3062         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RD, *ip);
3063       if (pinfo & INSN_WRITE_GPR_T)
3064         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RT, *ip);
3065       if (pinfo & INSN_WRITE_GPR_S)
3066         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RS, *ip);
3067       if (pinfo & INSN_WRITE_GPR_31)
3068         mask |= 1 << RA;
3069       if (pinfo2 & INSN2_WRITE_GPR_Z)
3070         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, RZ, *ip);
3071     }
3072   if (mips_opts.micromips)
3073     {
3074       if (pinfo2 & INSN2_WRITE_GPR_MB)
3075         mask |= 1 << micromips_to_32_reg_b_map[EXTRACT_OPERAND (1, MB, *ip)];
3076       if (pinfo2 & INSN2_WRITE_GPR_MHI)
3077         {
3078           mask |= 1 << micromips_to_32_reg_h_map[EXTRACT_OPERAND (1, MH, *ip)];
3079           mask |= 1 << micromips_to_32_reg_i_map[EXTRACT_OPERAND (1, MI, *ip)];
3080         }
3081       if (pinfo2 & INSN2_WRITE_GPR_MJ)
3082         mask |= 1 << EXTRACT_OPERAND (1, MJ, *ip);
3083       if (pinfo2 & INSN2_WRITE_GPR_MP)
3084         mask |= 1 << EXTRACT_OPERAND (1, MP, *ip);
3085     }
3086   /* Don't include register 0.  */
3087   return mask & ~1;
3088 }
3089
3090 /* Return the mask of floating-point registers that IP reads.  */
3091
3092 static unsigned int
3093 fpr_read_mask (const struct mips_cl_insn *ip)
3094 {
3095   unsigned long pinfo, pinfo2;
3096   unsigned int mask;
3097
3098   mask = 0;
3099   pinfo = ip->insn_mo->pinfo;
3100   pinfo2 = ip->insn_mo->pinfo2;
3101   if (!mips_opts.mips16)
3102     {
3103       if (pinfo2 & INSN2_READ_FPR_D)
3104         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FD, *ip);
3105       if (pinfo & INSN_READ_FPR_S)
3106         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FS, *ip);
3107       if (pinfo & INSN_READ_FPR_T)
3108         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FT, *ip);
3109       if (pinfo & INSN_READ_FPR_R)
3110         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FR, *ip);
3111       if (pinfo2 & INSN2_READ_FPR_Z)
3112         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FZ, *ip);
3113     }
3114   /* Conservatively treat all operands to an FP_D instruction are doubles.
3115      (This is overly pessimistic for things like cvt.d.s.)  */
3116   if (HAVE_32BIT_FPRS && (pinfo & FP_D))
3117     mask |= mask << 1;
3118   return mask;
3119 }
3120
3121 /* Return the mask of floating-point registers that IP writes.  */
3122
3123 static unsigned int
3124 fpr_write_mask (const struct mips_cl_insn *ip)
3125 {
3126   unsigned long pinfo, pinfo2;
3127   unsigned int mask;
3128
3129   mask = 0;
3130   pinfo = ip->insn_mo->pinfo;
3131   pinfo2 = ip->insn_mo->pinfo2;
3132   if (!mips_opts.mips16)
3133     {
3134       if (pinfo & INSN_WRITE_FPR_D)
3135         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FD, *ip);
3136       if (pinfo & INSN_WRITE_FPR_S)
3137         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FS, *ip);
3138       if (pinfo & INSN_WRITE_FPR_T)
3139         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FT, *ip);
3140       if (pinfo2 & INSN2_WRITE_FPR_Z)
3141         mask |= 1 << EXTRACT_OPERAND (mips_opts.micromips, FZ, *ip);
3142     }
3143   /* Conservatively treat all operands to an FP_D instruction are doubles.
3144      (This is overly pessimistic for things like cvt.s.d.)  */
3145   if (HAVE_32BIT_FPRS && (pinfo & FP_D))
3146     mask |= mask << 1;
3147   return mask;
3148 }
3149
3150 /* Classify an instruction according to the FIX_VR4120_* enumeration.
3151    Return NUM_FIX_VR4120_CLASSES if the instruction isn't affected
3152    by VR4120 errata.  */
3153
3154 static unsigned int
3155 classify_vr4120_insn (const char *name)
3156 {
3157   if (strncmp (name, "macc", 4) == 0)
3158     return FIX_VR4120_MACC;
3159   if (strncmp (name, "dmacc", 5) == 0)
3160     return FIX_VR4120_DMACC;
3161   if (strncmp (name, "mult", 4) == 0)
3162     return FIX_VR4120_MULT;
3163   if (strncmp (name, "dmult", 5) == 0)
3164     return FIX_VR4120_DMULT;
3165   if (strstr (name, "div"))
3166     return FIX_VR4120_DIV;
3167   if (strcmp (name, "mtlo") == 0 || strcmp (name, "mthi") == 0)
3168     return FIX_VR4120_MTHILO;
3169   return NUM_FIX_VR4120_CLASSES;
3170 }
3171
3172 #define INSN_ERET  0x42000018
3173 #define INSN_DERET 0x4200001f
3174
3175 /* Return the number of instructions that must separate INSN1 and INSN2,
3176    where INSN1 is the earlier instruction.  Return the worst-case value
3177    for any INSN2 if INSN2 is null.  */
3178
3179 static unsigned int
3180 insns_between (const struct mips_cl_insn *insn1,
3181                const struct mips_cl_insn *insn2)
3182 {
3183   unsigned long pinfo1, pinfo2;
3184   unsigned int mask;
3185
3186   /* This function needs to know which pinfo flags are set for INSN2
3187      and which registers INSN2 uses.  The former is stored in PINFO2 and
3188      the latter is tested via INSN2_USES_GPR.  If INSN2 is null, PINFO2
3189      will have every flag set and INSN2_USES_GPR will always return true.  */
3190   pinfo1 = insn1->insn_mo->pinfo;
3191   pinfo2 = insn2 ? insn2->insn_mo->pinfo : ~0U;
3192
3193 #define INSN2_USES_GPR(REG) \
3194   (insn2 == NULL || (gpr_read_mask (insn2) & (1U << (REG))) != 0)
3195
3196   /* For most targets, write-after-read dependencies on the HI and LO
3197      registers must be separated by at least two instructions.  */
3198   if (!hilo_interlocks)
3199     {
3200       if ((pinfo1 & INSN_READ_LO) && (pinfo2 & INSN_WRITE_LO))
3201         return 2;
3202       if ((pinfo1 & INSN_READ_HI) && (pinfo2 & INSN_WRITE_HI))
3203         return 2;
3204     }
3205
3206   /* If we're working around r7000 errata, there must be two instructions
3207      between an mfhi or mflo and any instruction that uses the result.  */
3208   if (mips_7000_hilo_fix
3209       && !mips_opts.micromips
3210       && MF_HILO_INSN (pinfo1)
3211       && INSN2_USES_GPR (EXTRACT_OPERAND (0, RD, *insn1)))
3212     return 2;
3213
3214   /* If we're working around 24K errata, one instruction is required
3215      if an ERET or DERET is followed by a branch instruction.  */
3216   if (mips_fix_24k && !mips_opts.micromips)
3217     {
3218       if (insn1->insn_opcode == INSN_ERET
3219           || insn1->insn_opcode == INSN_DERET)
3220         {
3221           if (insn2 == NULL
3222               || insn2->insn_opcode == INSN_ERET
3223               || insn2->insn_opcode == INSN_DERET
3224               || delayed_branch_p (insn2))
3225             return 1;
3226         }
3227     }
3228
3229   /* If working around VR4120 errata, check for combinations that need
3230      a single intervening instruction.  */
3231   if (mips_fix_vr4120 && !mips_opts.micromips)
3232     {
3233       unsigned int class1, class2;
3234
3235       class1 = classify_vr4120_insn (insn1->insn_mo->name);
3236       if (class1 != NUM_FIX_VR4120_CLASSES && vr4120_conflicts[class1] != 0)
3237         {
3238           if (insn2 == NULL)
3239             return 1;
3240           class2 = classify_vr4120_insn (insn2->insn_mo->name);
3241           if (vr4120_conflicts[class1] & (1 << class2))
3242             return 1;
3243         }
3244     }
3245
3246   if (!HAVE_CODE_COMPRESSION)
3247     {
3248       /* Check for GPR or coprocessor load delays.  All such delays
3249          are on the RT register.  */
3250       /* Itbl support may require additional care here.  */
3251       if ((!gpr_interlocks && (pinfo1 & INSN_LOAD_MEMORY_DELAY))
3252           || (!cop_interlocks && (pinfo1 & INSN_LOAD_COPROC_DELAY)))
3253         {
3254           know (pinfo1 & INSN_WRITE_GPR_T);
3255           if (INSN2_USES_GPR (EXTRACT_OPERAND (0, RT, *insn1)))
3256             return 1;
3257         }
3258
3259       /* Check for generic coprocessor hazards.
3260
3261          This case is not handled very well.  There is no special
3262          knowledge of CP0 handling, and the coprocessors other than
3263          the floating point unit are not distinguished at all.  */
3264       /* Itbl support may require additional care here. FIXME!
3265          Need to modify this to include knowledge about
3266          user specified delays!  */
3267       else if ((!cop_interlocks && (pinfo1 & INSN_COPROC_MOVE_DELAY))
3268                || (!cop_mem_interlocks && (pinfo1 & INSN_COPROC_MEMORY_DELAY)))
3269         {
3270           /* Handle cases where INSN1 writes to a known general coprocessor
3271              register.  There must be a one instruction delay before INSN2
3272              if INSN2 reads that register, otherwise no delay is needed.  */
3273           mask = fpr_write_mask (insn1);
3274           if (mask != 0)
3275             {
3276               if (!insn2 || (mask & fpr_read_mask (insn2)) != 0)
3277                 return 1;
3278             }
3279           else
3280             {
3281               /* Read-after-write dependencies on the control registers
3282                  require a two-instruction gap.  */
3283               if ((pinfo1 & INSN_WRITE_COND_CODE)
3284                   && (pinfo2 & INSN_READ_COND_CODE))
3285                 return 2;
3286
3287               /* We don't know exactly what INSN1 does.  If INSN2 is
3288                  also a coprocessor instruction, assume there must be
3289                  a one instruction gap.  */
3290               if (pinfo2 & INSN_COP)
3291                 return 1;
3292             }
3293         }
3294
3295       /* Check for read-after-write dependencies on the coprocessor
3296          control registers in cases where INSN1 does not need a general
3297          coprocessor delay.  This means that INSN1 is a floating point
3298          comparison instruction.  */
3299       /* Itbl support may require additional care here.  */
3300       else if (!cop_interlocks
3301                && (pinfo1 & INSN_WRITE_COND_CODE)
3302                && (pinfo2 & INSN_READ_COND_CODE))
3303         return 1;
3304     }
3305
3306 #undef INSN2_USES_GPR
3307
3308   return 0;
3309 }
3310
3311 /* Return the number of nops that would be needed to work around the
3312    VR4130 mflo/mfhi errata if instruction INSN immediately followed
3313    the MAX_VR4130_NOPS instructions described by HIST.  Ignore hazards
3314    that are contained within the first IGNORE instructions of HIST.  */
3315
3316 static int
3317 nops_for_vr4130 (int ignore, const struct mips_cl_insn *hist,
3318                  const struct mips_cl_insn *insn)
3319 {
3320   int i, j;
3321   unsigned int mask;
3322
3323   /* Check if the instruction writes to HI or LO.  MTHI and MTLO
3324      are not affected by the errata.  */
3325   if (insn != 0
3326       && ((insn->insn_mo->pinfo & (INSN_WRITE_HI | INSN_WRITE_LO)) == 0
3327           || strcmp (insn->insn_mo->name, "mtlo") == 0
3328           || strcmp (insn->insn_mo->name, "mthi") == 0))
3329     return 0;
3330
3331   /* Search for the first MFLO or MFHI.  */
3332   for (i = 0; i < MAX_VR4130_NOPS; i++)
3333     if (MF_HILO_INSN (hist[i].insn_mo->pinfo))
3334       {
3335         /* Extract the destination register.  */
3336         mask = gpr_write_mask (&hist[i]);
3337
3338         /* No nops are needed if INSN reads that register.  */
3339         if (insn != NULL && (gpr_read_mask (insn) & mask) != 0)
3340           return 0;
3341
3342         /* ...or if any of the intervening instructions do.  */
3343         for (j = 0; j < i; j++)
3344           if (gpr_read_mask (&hist[j]) & mask)
3345             return 0;
3346
3347         if (i >= ignore)
3348           return MAX_VR4130_NOPS - i;
3349       }
3350   return 0;
3351 }
3352
3353 #define BASE_REG_EQ(INSN1, INSN2)       \
3354   ((((INSN1) >> OP_SH_RS) & OP_MASK_RS) \
3355       == (((INSN2) >> OP_SH_RS) & OP_MASK_RS))
3356
3357 /* Return the minimum alignment for this store instruction.  */
3358
3359 static int
3360 fix_24k_align_to (const struct mips_opcode *mo)
3361 {
3362   if (strcmp (mo->name, "sh") == 0)
3363     return 2;
3364
3365   if (strcmp (mo->name, "swc1") == 0
3366       || strcmp (mo->name, "swc2") == 0
3367       || strcmp (mo->name, "sw") == 0
3368       || strcmp (mo->name, "sc") == 0
3369       || strcmp (mo->name, "s.s") == 0)
3370     return 4;
3371
3372   if (strcmp (mo->name, "sdc1") == 0
3373       || strcmp (mo->name, "sdc2") == 0
3374       || strcmp (mo->name, "s.d") == 0)
3375     return 8;
3376
3377   /* sb, swl, swr */
3378   return 1;
3379 }
3380
3381 struct fix_24k_store_info
3382   {
3383     /* Immediate offset, if any, for this store instruction.  */
3384     short off;
3385     /* Alignment required by this store instruction.  */
3386     int align_to;
3387     /* True for register offsets.  */
3388     int register_offset;
3389   };
3390
3391 /* Comparison function used by qsort.  */
3392
3393 static int
3394 fix_24k_sort (const void *a, const void *b)
3395 {
3396   const struct fix_24k_store_info *pos1 = a;
3397   const struct fix_24k_store_info *pos2 = b;
3398
3399   return (pos1->off - pos2->off);
3400 }
3401
3402 /* INSN is a store instruction.  Try to record the store information
3403    in STINFO.  Return false if the information isn't known.  */
3404
3405 static bfd_boolean
3406 fix_24k_record_store_info (struct fix_24k_store_info *stinfo,
3407                            const struct mips_cl_insn *insn)
3408 {
3409   /* The instruction must have a known offset.  */
3410   if (!insn->complete_p || !strstr (insn->insn_mo->args, "o("))
3411     return FALSE;
3412
3413   stinfo->off = (insn->insn_opcode >> OP_SH_IMMEDIATE) & OP_MASK_IMMEDIATE;
3414   stinfo->align_to = fix_24k_align_to (insn->insn_mo);
3415   return TRUE;
3416 }
3417
3418 /* Return the number of nops that would be needed to work around the 24k
3419    "lost data on stores during refill" errata if instruction INSN
3420    immediately followed the 2 instructions described by HIST.
3421    Ignore hazards that are contained within the first IGNORE
3422    instructions of HIST.
3423
3424    Problem: The FSB (fetch store buffer) acts as an intermediate buffer
3425    for the data cache refills and store data. The following describes
3426    the scenario where the store data could be lost.
3427
3428    * A data cache miss, due to either a load or a store, causing fill
3429      data to be supplied by the memory subsystem
3430    * The first three doublewords of fill data are returned and written
3431      into the cache
3432    * A sequence of four stores occurs in consecutive cycles around the
3433      final doubleword of the fill:
3434    * Store A
3435    * Store B
3436    * Store C
3437    * Zero, One or more instructions
3438    * Store D
3439
3440    The four stores A-D must be to different doublewords of the line that
3441    is being filled. The fourth instruction in the sequence above permits
3442    the fill of the final doubleword to be transferred from the FSB into
3443    the cache. In the sequence above, the stores may be either integer
3444    (sb, sh, sw, swr, swl, sc) or coprocessor (swc1/swc2, sdc1/sdc2,
3445    swxc1, sdxc1, suxc1) stores, as long as the four stores are to
3446    different doublewords on the line. If the floating point unit is
3447    running in 1:2 mode, it is not possible to create the sequence above
3448    using only floating point store instructions.
3449
3450    In this case, the cache line being filled is incorrectly marked
3451    invalid, thereby losing the data from any store to the line that
3452    occurs between the original miss and the completion of the five
3453    cycle sequence shown above.
3454
3455    The workarounds are:
3456
3457    * Run the data cache in write-through mode.
3458    * Insert a non-store instruction between
3459      Store A and Store B or Store B and Store C.  */
3460   
3461 static int
3462 nops_for_24k (int ignore, const struct mips_cl_insn *hist,
3463               const struct mips_cl_insn *insn)
3464 {
3465   struct fix_24k_store_info pos[3];
3466   int align, i, base_offset;
3467
3468   if (ignore >= 2)
3469     return 0;
3470
3471   /* If the previous instruction wasn't a store, there's nothing to
3472      worry about.  */
3473   if ((hist[0].insn_mo->pinfo & INSN_STORE_MEMORY) == 0)
3474     return 0;
3475
3476   /* If the instructions after the previous one are unknown, we have
3477      to assume the worst.  */
3478   if (!insn)
3479     return 1;
3480
3481   /* Check whether we are dealing with three consecutive stores.  */
3482   if ((insn->insn_mo->pinfo & INSN_STORE_MEMORY) == 0
3483       || (hist[1].insn_mo->pinfo & INSN_STORE_MEMORY) == 0)
3484     return 0;
3485
3486   /* If we don't know the relationship between the store addresses,
3487      assume the worst.  */
3488   if (!BASE_REG_EQ (insn->insn_opcode, hist[0].insn_opcode)
3489       || !BASE_REG_EQ (insn->insn_opcode, hist[1].insn_opcode))
3490     return 1;
3491
3492   if (!fix_24k_record_store_info (&pos[0], insn)
3493       || !fix_24k_record_store_info (&pos[1], &hist[0])
3494       || !fix_24k_record_store_info (&pos[2], &hist[1]))
3495     return 1;
3496
3497   qsort (&pos, 3, sizeof (struct fix_24k_store_info), fix_24k_sort);
3498
3499   /* Pick a value of ALIGN and X such that all offsets are adjusted by
3500      X bytes and such that the base register + X is known to be aligned
3501      to align bytes.  */
3502
3503   if (((insn->insn_opcode >> OP_SH_RS) & OP_MASK_RS) == SP)
3504     align = 8;
3505   else
3506     {
3507       align = pos[0].align_to;
3508       base_offset = pos[0].off;
3509       for (i = 1; i < 3; i++)
3510         if (align < pos[i].align_to)
3511           {
3512             align = pos[i].align_to;
3513             base_offset = pos[i].off;
3514           }
3515       for (i = 0; i < 3; i++)
3516         pos[i].off -= base_offset;
3517     }
3518
3519   pos[0].off &= ~align + 1;
3520   pos[1].off &= ~align + 1;
3521   pos[2].off &= ~align + 1;
3522
3523   /* If any two stores write to the same chunk, they also write to the
3524      same doubleword.  The offsets are still sorted at this point.  */
3525   if (pos[0].off == pos[1].off || pos[1].off == pos[2].off)
3526     return 0;
3527
3528   /* A range of at least 9 bytes is needed for the stores to be in
3529      non-overlapping doublewords.  */
3530   if (pos[2].off - pos[0].off <= 8)
3531     return 0;
3532
3533   if (pos[2].off - pos[1].off >= 24
3534       || pos[1].off - pos[0].off >= 24
3535       || pos[2].off - pos[0].off >= 32)
3536     return 0;
3537
3538   return 1;
3539 }
3540
3541 /* Return the number of nops that would be needed if instruction INSN
3542    immediately followed the MAX_NOPS instructions given by HIST,
3543    where HIST[0] is the most recent instruction.  Ignore hazards
3544    between INSN and the first IGNORE instructions in HIST.
3545
3546    If INSN is null, return the worse-case number of nops for any
3547    instruction.  */
3548
3549 static int
3550 nops_for_insn (int ignore, const struct mips_cl_insn *hist,
3551                const struct mips_cl_insn *insn)
3552 {
3553   int i, nops, tmp_nops;
3554
3555   nops = 0;
3556   for (i = ignore; i < MAX_DELAY_NOPS; i++)
3557     {
3558       tmp_nops = insns_between (hist + i, insn) - i;
3559       if (tmp_nops > nops)
3560         nops = tmp_nops;
3561     }
3562
3563   if (mips_fix_vr4130 && !mips_opts.micromips)
3564     {
3565       tmp_nops = nops_for_vr4130 (ignore, hist, insn);
3566       if (tmp_nops > nops)
3567         nops = tmp_nops;
3568     }
3569
3570   if (mips_fix_24k && !mips_opts.micromips)
3571     {
3572       tmp_nops = nops_for_24k (ignore, hist, insn);
3573       if (tmp_nops > nops)
3574         nops = tmp_nops;
3575     }
3576
3577   return nops;
3578 }
3579
3580 /* The variable arguments provide NUM_INSNS extra instructions that
3581    might be added to HIST.  Return the largest number of nops that
3582    would be needed after the extended sequence, ignoring hazards
3583    in the first IGNORE instructions.  */
3584
3585 static int
3586 nops_for_sequence (int num_insns, int ignore,
3587                    const struct mips_cl_insn *hist, ...)
3588 {
3589   va_list args;
3590   struct mips_cl_insn buffer[MAX_NOPS];
3591   struct mips_cl_insn *cursor;
3592   int nops;
3593
3594   va_start (args, hist);
3595   cursor = buffer + num_insns;
3596   memcpy (cursor, hist, (MAX_NOPS - num_insns) * sizeof (*cursor));
3597   while (cursor > buffer)
3598     *--cursor = *va_arg (args, const struct mips_cl_insn *);
3599
3600   nops = nops_for_insn (ignore, buffer, NULL);
3601   va_end (args);
3602   return nops;
3603 }
3604
3605 /* Like nops_for_insn, but if INSN is a branch, take into account the
3606    worst-case delay for the branch target.  */
3607
3608 static int
3609 nops_for_insn_or_target (int ignore, const struct mips_cl_insn *hist,
3610                          const struct mips_cl_insn *insn)
3611 {
3612   int nops, tmp_nops;
3613
3614   nops = nops_for_insn (ignore, hist, insn);
3615   if (delayed_branch_p (insn))
3616     {
3617       tmp_nops = nops_for_sequence (2, ignore ? ignore + 2 : 0,
3618                                     hist, insn, get_delay_slot_nop (insn));
3619       if (tmp_nops > nops)
3620         nops = tmp_nops;
3621     }
3622   else if (compact_branch_p (insn))
3623     {
3624       tmp_nops = nops_for_sequence (1, ignore ? ignore + 1 : 0, hist, insn);
3625       if (tmp_nops > nops)
3626         nops = tmp_nops;
3627     }
3628   return nops;
3629 }
3630
3631 /* Fix NOP issue: Replace nops by "or at,at,zero".  */
3632
3633 static void
3634 fix_loongson2f_nop (struct mips_cl_insn * ip)
3635 {
3636   gas_assert (!HAVE_CODE_COMPRESSION);
3637   if (strcmp (ip->insn_mo->name, "nop") == 0)
3638     ip->insn_opcode = LOONGSON2F_NOP_INSN;
3639 }
3640
3641 /* Fix Jump Issue: Eliminate instruction fetch from outside 256M region
3642                    jr target pc &= 'hffff_ffff_cfff_ffff.  */
3643
3644 static void
3645 fix_loongson2f_jump (struct mips_cl_insn * ip)
3646 {
3647   gas_assert (!HAVE_CODE_COMPRESSION);
3648   if (strcmp (ip->insn_mo->name, "j") == 0
3649       || strcmp (ip->insn_mo->name, "jr") == 0
3650       || strcmp (ip->insn_mo->name, "jalr") == 0)
3651     {
3652       int sreg;
3653       expressionS ep;
3654
3655       if (! mips_opts.at)
3656         return;
3657
3658       sreg = EXTRACT_OPERAND (0, RS, *ip);
3659       if (sreg == ZERO || sreg == KT0 || sreg == KT1 || sreg == ATREG)
3660         return;
3661
3662       ep.X_op = O_constant;
3663       ep.X_add_number = 0xcfff0000;
3664       macro_build (&ep, "lui", "t,u", ATREG, BFD_RELOC_HI16);
3665       ep.X_add_number = 0xffff;
3666       macro_build (&ep, "ori", "t,r,i", ATREG, ATREG, BFD_RELOC_LO16);
3667       macro_build (NULL, "and", "d,v,t", sreg, sreg, ATREG);
3668     }
3669 }
3670
3671 static void
3672 fix_loongson2f (struct mips_cl_insn * ip)
3673 {
3674   if (mips_fix_loongson2f_nop)
3675     fix_loongson2f_nop (ip);
3676
3677   if (mips_fix_loongson2f_jump)
3678     fix_loongson2f_jump (ip);
3679 }
3680
3681 /* IP is a branch that has a delay slot, and we need to fill it
3682    automatically.   Return true if we can do that by swapping IP
3683    with the previous instruction.  */
3684
3685 static bfd_boolean
3686 can_swap_branch_p (struct mips_cl_insn *ip)
3687 {
3688   unsigned long pinfo, pinfo2, prev_pinfo, prev_pinfo2;
3689   unsigned int gpr_read, gpr_write, prev_gpr_read, prev_gpr_write;
3690
3691   /* -O2 and above is required for this optimization.  */
3692   if (mips_optimize < 2)
3693     return FALSE;
3694
3695   /* If we have seen .set volatile or .set nomove, don't optimize.  */
3696   if (mips_opts.nomove)
3697     return FALSE;
3698
3699   /* We can't swap if the previous instruction's position is fixed.  */
3700   if (history[0].fixed_p)
3701     return FALSE;
3702
3703   /* If the previous previous insn was in a .set noreorder, we can't
3704      swap.  Actually, the MIPS assembler will swap in this situation.
3705      However, gcc configured -with-gnu-as will generate code like
3706
3707         .set    noreorder
3708         lw      $4,XXX
3709         .set    reorder
3710         INSN
3711         bne     $4,$0,foo
3712
3713      in which we can not swap the bne and INSN.  If gcc is not configured
3714      -with-gnu-as, it does not output the .set pseudo-ops.  */
3715   if (history[1].noreorder_p)
3716     return FALSE;
3717
3718   /* If the previous instruction had a fixup in mips16 mode, we can not swap.
3719      This means that the previous instruction was a 4-byte one anyhow.  */
3720   if (mips_opts.mips16 && history[0].fixp[0])
3721     return FALSE;
3722
3723   /* If the branch is itself the target of a branch, we can not swap.
3724      We cheat on this; all we check for is whether there is a label on
3725      this instruction.  If there are any branches to anything other than
3726      a label, users must use .set noreorder.  */
3727   if (seg_info (now_seg)->label_list)
3728     return FALSE;
3729
3730   /* If the previous instruction is in a variant frag other than this
3731      branch's one, we cannot do the swap.  This does not apply to
3732      MIPS16 code, which uses variant frags for different purposes.  */
3733   if (!mips_opts.mips16
3734       && history[0].frag
3735       && history[0].frag->fr_type == rs_machine_dependent)
3736     return FALSE;
3737
3738   /* We do not swap with instructions that cannot architecturally
3739      be placed in a branch delay slot, such as SYNC or ERET.  We
3740      also refrain from swapping with a trap instruction, since it
3741      complicates trap handlers to have the trap instruction be in
3742      a delay slot.  */
3743   prev_pinfo = history[0].insn_mo->pinfo;
3744   if (prev_pinfo & INSN_NO_DELAY_SLOT)
3745     return FALSE;
3746
3747   /* Check for conflicts between the branch and the instructions
3748      before the candidate delay slot.  */
3749   if (nops_for_insn (0, history + 1, ip) > 0)
3750     return FALSE;
3751
3752   /* Check for conflicts between the swapped sequence and the
3753      target of the branch.  */
3754   if (nops_for_sequence (2, 0, history + 1, ip, history) > 0)
3755     return FALSE;
3756
3757   /* If the branch reads a register that the previous
3758      instruction sets, we can not swap.  */
3759   gpr_read = gpr_read_mask (ip);
3760   prev_gpr_write = gpr_write_mask (&history[0]);
3761   if (gpr_read & prev_gpr_write)
3762     return FALSE;
3763
3764   /* If the branch writes a register that the previous
3765      instruction sets, we can not swap.  */
3766   gpr_write = gpr_write_mask (ip);
3767   if (gpr_write & prev_gpr_write)
3768     return FALSE;
3769
3770   /* If the branch writes a register that the previous
3771      instruction reads, we can not swap.  */
3772   prev_gpr_read = gpr_read_mask (&history[0]);
3773   if (gpr_write & prev_gpr_read)
3774     return FALSE;
3775
3776   /* If one instruction sets a condition code and the
3777      other one uses a condition code, we can not swap.  */
3778   pinfo = ip->insn_mo->pinfo;
3779   if ((pinfo & INSN_READ_COND_CODE)
3780       && (prev_pinfo & INSN_WRITE_COND_CODE))
3781     return FALSE;
3782   if ((pinfo & INSN_WRITE_COND_CODE)
3783       && (prev_pinfo & INSN_READ_COND_CODE))
3784     return FALSE;
3785
3786   /* If the previous instruction uses the PC, we can not swap.  */
3787   prev_pinfo2 = history[0].insn_mo->pinfo2;
3788   if (mips_opts.mips16 && (prev_pinfo & MIPS16_INSN_READ_PC))
3789     return FALSE;
3790   if (mips_opts.micromips && (prev_pinfo2 & INSN2_READ_PC))
3791     return FALSE;
3792
3793   /* If the previous instruction has an incorrect size for a fixed
3794      branch delay slot in microMIPS mode, we cannot swap.  */
3795   pinfo2 = ip->insn_mo->pinfo2;
3796   if (mips_opts.micromips
3797       && (pinfo2 & INSN2_BRANCH_DELAY_16BIT)
3798       && insn_length (history) != 2)
3799     return FALSE;
3800   if (mips_opts.micromips
3801       && (pinfo2 & INSN2_BRANCH_DELAY_32BIT)
3802       && insn_length (history) != 4)
3803     return FALSE;
3804
3805   return TRUE;
3806 }
3807
3808 /* Decide how we should add IP to the instruction stream.  */
3809
3810 static enum append_method
3811 get_append_method (struct mips_cl_insn *ip)
3812 {
3813   unsigned long pinfo;
3814
3815   /* The relaxed version of a macro sequence must be inherently
3816      hazard-free.  */
3817   if (mips_relax.sequence == 2)
3818     return APPEND_ADD;
3819
3820   /* We must not dabble with instructions in a ".set norerorder" block.  */
3821   if (mips_opts.noreorder)
3822     return APPEND_ADD;
3823
3824   /* Otherwise, it's our responsibility to fill branch delay slots.  */
3825   if (delayed_branch_p (ip))
3826     {
3827       if (!branch_likely_p (ip) && can_swap_branch_p (ip))
3828         return APPEND_SWAP;
3829
3830       pinfo = ip->insn_mo->pinfo;
3831       if (mips_opts.mips16
3832           && ISA_SUPPORTS_MIPS16E
3833           && (pinfo & (MIPS16_INSN_READ_X | MIPS16_INSN_READ_31)))
3834         return APPEND_ADD_COMPACT;
3835
3836       return APPEND_ADD_WITH_NOP;
3837     }
3838
3839   return APPEND_ADD;
3840 }
3841
3842 /* IP is a MIPS16 instruction whose opcode we have just changed.
3843    Point IP->insn_mo to the new opcode's definition.  */
3844
3845 static void
3846 find_altered_mips16_opcode (struct mips_cl_insn *ip)
3847 {
3848   const struct mips_opcode *mo, *end;
3849
3850   end = &mips16_opcodes[bfd_mips16_num_opcodes];
3851   for (mo = ip->insn_mo; mo < end; mo++)
3852     if ((ip->insn_opcode & mo->mask) == mo->match)
3853       {
3854         ip->insn_mo = mo;
3855         return;
3856       }
3857   abort ();
3858 }
3859
3860 /* For microMIPS macros, we need to generate a local number label
3861    as the target of branches.  */
3862 #define MICROMIPS_LABEL_CHAR            '\037'
3863 static unsigned long micromips_target_label;
3864 static char micromips_target_name[32];
3865
3866 static char *
3867 micromips_label_name (void)
3868 {
3869   char *p = micromips_target_name;
3870   char symbol_name_temporary[24];
3871   unsigned long l;
3872   int i;
3873
3874   if (*p)
3875     return p;
3876
3877   i = 0;
3878   l = micromips_target_label;
3879 #ifdef LOCAL_LABEL_PREFIX
3880   *p++ = LOCAL_LABEL_PREFIX;
3881 #endif
3882   *p++ = 'L';
3883   *p++ = MICROMIPS_LABEL_CHAR;
3884   do
3885     {
3886       symbol_name_temporary[i++] = l % 10 + '0';
3887       l /= 10;
3888     }
3889   while (l != 0);
3890   while (i > 0)
3891     *p++ = symbol_name_temporary[--i];
3892   *p = '\0';
3893
3894   return micromips_target_name;
3895 }
3896
3897 static void
3898 micromips_label_expr (expressionS *label_expr)
3899 {
3900   label_expr->X_op = O_symbol;
3901   label_expr->X_add_symbol = symbol_find_or_make (micromips_label_name ());
3902   label_expr->X_add_number = 0;
3903 }
3904
3905 static void
3906 micromips_label_inc (void)
3907 {
3908   micromips_target_label++;
3909   *micromips_target_name = '\0';
3910 }
3911
3912 static void
3913 micromips_add_label (void)
3914 {
3915   symbolS *s;
3916
3917   s = colon (micromips_label_name ());
3918   micromips_label_inc ();
3919 #if defined(OBJ_ELF) || defined(OBJ_MAYBE_ELF)
3920   if (IS_ELF)
3921     S_SET_OTHER (s, ELF_ST_SET_MICROMIPS (S_GET_OTHER (s)));
3922 #else
3923   (void) s;
3924 #endif
3925 }
3926
3927 /* If assembling microMIPS code, then return the microMIPS reloc
3928    corresponding to the requested one if any.  Otherwise return
3929    the reloc unchanged.  */
3930
3931 static bfd_reloc_code_real_type
3932 micromips_map_reloc (bfd_reloc_code_real_type reloc)
3933 {
3934   static const bfd_reloc_code_real_type relocs[][2] =
3935     {
3936       /* Keep sorted incrementally by the left-hand key.  */
3937       { BFD_RELOC_16_PCREL_S2, BFD_RELOC_MICROMIPS_16_PCREL_S1 },
3938       { BFD_RELOC_GPREL16, BFD_RELOC_MICROMIPS_GPREL16 },
3939       { BFD_RELOC_MIPS_JMP, BFD_RELOC_MICROMIPS_JMP },
3940       { BFD_RELOC_HI16, BFD_RELOC_MICROMIPS_HI16 },
3941       { BFD_RELOC_HI16_S, BFD_RELOC_MICROMIPS_HI16_S },
3942       { BFD_RELOC_LO16, BFD_RELOC_MICROMIPS_LO16 },
3943       { BFD_RELOC_MIPS_LITERAL, BFD_RELOC_MICROMIPS_LITERAL },
3944       { BFD_RELOC_MIPS_GOT16, BFD_RELOC_MICROMIPS_GOT16 },
3945       { BFD_RELOC_MIPS_CALL16, BFD_RELOC_MICROMIPS_CALL16 },
3946       { BFD_RELOC_MIPS_GOT_HI16, BFD_RELOC_MICROMIPS_GOT_HI16 },
3947       { BFD_RELOC_MIPS_GOT_LO16, BFD_RELOC_MICROMIPS_GOT_LO16 },
3948       { BFD_RELOC_MIPS_CALL_HI16, BFD_RELOC_MICROMIPS_CALL_HI16 },
3949       { BFD_RELOC_MIPS_CALL_LO16, BFD_RELOC_MICROMIPS_CALL_LO16 },
3950       { BFD_RELOC_MIPS_SUB, BFD_RELOC_MICROMIPS_SUB },
3951       { BFD_RELOC_MIPS_GOT_PAGE, BFD_RELOC_MICROMIPS_GOT_PAGE },
3952       { BFD_RELOC_MIPS_GOT_OFST, BFD_RELOC_MICROMIPS_GOT_OFST },
3953       { BFD_RELOC_MIPS_GOT_DISP, BFD_RELOC_MICROMIPS_GOT_DISP },
3954       { BFD_RELOC_MIPS_HIGHEST, BFD_RELOC_MICROMIPS_HIGHEST },
3955       { BFD_RELOC_MIPS_HIGHER, BFD_RELOC_MICROMIPS_HIGHER },
3956       { BFD_RELOC_MIPS_SCN_DISP, BFD_RELOC_MICROMIPS_SCN_DISP },
3957       { BFD_RELOC_MIPS_TLS_GD, BFD_RELOC_MICROMIPS_TLS_GD },
3958       { BFD_RELOC_MIPS_TLS_LDM, BFD_RELOC_MICROMIPS_TLS_LDM },
3959       { BFD_RELOC_MIPS_TLS_DTPREL_HI16, BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16 },
3960       { BFD_RELOC_MIPS_TLS_DTPREL_LO16, BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16 },
3961       { BFD_RELOC_MIPS_TLS_GOTTPREL, BFD_RELOC_MICROMIPS_TLS_GOTTPREL },
3962       { BFD_RELOC_MIPS_TLS_TPREL_HI16, BFD_RELOC_MICROMIPS_TLS_TPREL_HI16 },
3963       { BFD_RELOC_MIPS_TLS_TPREL_LO16, BFD_RELOC_MICROMIPS_TLS_TPREL_LO16 }
3964     };
3965   bfd_reloc_code_real_type r;
3966   size_t i;
3967
3968   if (!mips_opts.micromips)
3969     return reloc;
3970   for (i = 0; i < ARRAY_SIZE (relocs); i++)
3971     {
3972       r = relocs[i][0];
3973       if (r > reloc)
3974         return reloc;
3975       if (r == reloc)
3976         return relocs[i][1];
3977     }
3978   return reloc;
3979 }
3980
3981 /* Output an instruction.  IP is the instruction information.
3982    ADDRESS_EXPR is an operand of the instruction to be used with
3983    RELOC_TYPE.  EXPANSIONP is true if the instruction is part of
3984    a macro expansion.  */
3985
3986 static void
3987 append_insn (struct mips_cl_insn *ip, expressionS *address_expr,
3988              bfd_reloc_code_real_type *reloc_type, bfd_boolean expansionp)
3989 {
3990   unsigned long prev_pinfo2, pinfo;
3991   bfd_boolean relaxed_branch = FALSE;
3992   enum append_method method;
3993   bfd_boolean relax32;
3994   int branch_disp;
3995
3996   if (mips_fix_loongson2f && !HAVE_CODE_COMPRESSION)
3997     fix_loongson2f (ip);
3998
3999   mips_mark_labels ();
4000
4001   file_ase_mips16 |= mips_opts.mips16;
4002   file_ase_micromips |= mips_opts.micromips;
4003
4004   prev_pinfo2 = history[0].insn_mo->pinfo2;
4005   pinfo = ip->insn_mo->pinfo;
4006
4007   if (mips_opts.micromips
4008       && !expansionp
4009       && (((prev_pinfo2 & INSN2_BRANCH_DELAY_16BIT) != 0
4010            && micromips_insn_length (ip->insn_mo) != 2)
4011           || ((prev_pinfo2 & INSN2_BRANCH_DELAY_32BIT) != 0
4012               && micromips_insn_length (ip->insn_mo) != 4)))
4013     as_warn (_("Wrong size instruction in a %u-bit branch delay slot"),
4014              (prev_pinfo2 & INSN2_BRANCH_DELAY_16BIT) != 0 ? 16 : 32);
4015
4016   if (address_expr == NULL)
4017     ip->complete_p = 1;
4018   else if (*reloc_type <= BFD_RELOC_UNUSED
4019            && address_expr->X_op == O_constant)
4020     {
4021       unsigned int tmp;
4022
4023       ip->complete_p = 1;
4024       switch (*reloc_type)
4025         {
4026         case BFD_RELOC_32:
4027           ip->insn_opcode |= address_expr->X_add_number;
4028           break;
4029
4030         case BFD_RELOC_MIPS_HIGHEST:
4031           tmp = (address_expr->X_add_number + 0x800080008000ull) >> 48;
4032           ip->insn_opcode |= tmp & 0xffff;
4033           break;
4034
4035         case BFD_RELOC_MIPS_HIGHER:
4036           tmp = (address_expr->X_add_number + 0x80008000ull) >> 32;
4037           ip->insn_opcode |= tmp & 0xffff;
4038           break;
4039
4040         case BFD_RELOC_HI16_S:
4041           tmp = (address_expr->X_add_number + 0x8000) >> 16;
4042           ip->insn_opcode |= tmp & 0xffff;
4043           break;
4044
4045         case BFD_RELOC_HI16:
4046           ip->insn_opcode |= (address_expr->X_add_number >> 16) & 0xffff;
4047           break;
4048
4049         case BFD_RELOC_UNUSED:
4050         case BFD_RELOC_LO16:
4051         case BFD_RELOC_MIPS_GOT_DISP:
4052           ip->insn_opcode |= address_expr->X_add_number & 0xffff;
4053           break;
4054
4055         case BFD_RELOC_MIPS_JMP:
4056           {
4057             int shift;
4058
4059             shift = mips_opts.micromips ? 1 : 2;
4060             if ((address_expr->X_add_number & ((1 << shift) - 1)) != 0)
4061               as_bad (_("jump to misaligned address (0x%lx)"),
4062                       (unsigned long) address_expr->X_add_number);
4063             ip->insn_opcode |= ((address_expr->X_add_number >> shift)
4064                                 & 0x3ffffff);
4065             ip->complete_p = 0;
4066           }
4067           break;
4068
4069         case BFD_RELOC_MIPS16_JMP:
4070           if ((address_expr->X_add_number & 3) != 0)
4071             as_bad (_("jump to misaligned address (0x%lx)"),
4072                     (unsigned long) address_expr->X_add_number);
4073           ip->insn_opcode |=
4074             (((address_expr->X_add_number & 0x7c0000) << 3)
4075                | ((address_expr->X_add_number & 0xf800000) >> 7)
4076                | ((address_expr->X_add_number & 0x3fffc) >> 2));
4077           ip->complete_p = 0;
4078           break;
4079
4080         case BFD_RELOC_16_PCREL_S2:
4081           {
4082             int shift;
4083
4084             shift = mips_opts.micromips ? 1 : 2;
4085             if ((address_expr->X_add_number & ((1 << shift) - 1)) != 0)
4086               as_bad (_("branch to misaligned address (0x%lx)"),
4087                       (unsigned long) address_expr->X_add_number);
4088             if (!mips_relax_branch)
4089               {
4090                 if ((address_expr->X_add_number + (1 << (shift + 15)))
4091                     & ~((1 << (shift + 16)) - 1))
4092                   as_bad (_("branch address range overflow (0x%lx)"),
4093                           (unsigned long) address_expr->X_add_number);
4094                 ip->insn_opcode |= ((address_expr->X_add_number >> shift)
4095                                     & 0xffff);
4096               }
4097             ip->complete_p = 0;
4098           }
4099           break;
4100
4101         default:
4102           internalError ();
4103         }       
4104     }
4105
4106   if (mips_relax.sequence != 2 && !mips_opts.noreorder)
4107     {
4108       /* There are a lot of optimizations we could do that we don't.
4109          In particular, we do not, in general, reorder instructions.
4110          If you use gcc with optimization, it will reorder
4111          instructions and generally do much more optimization then we
4112          do here; repeating all that work in the assembler would only
4113          benefit hand written assembly code, and does not seem worth
4114          it.  */
4115       int nops = (mips_optimize == 0
4116                   ? nops_for_insn (0, history, NULL)
4117                   : nops_for_insn_or_target (0, history, ip));
4118       if (nops > 0)
4119         {
4120           fragS *old_frag;
4121           unsigned long old_frag_offset;
4122           int i;
4123
4124           old_frag = frag_now;
4125           old_frag_offset = frag_now_fix ();
4126
4127           for (i = 0; i < nops; i++)
4128             add_fixed_insn (NOP_INSN);
4129           insert_into_history (0, nops, NOP_INSN);
4130
4131           if (listing)
4132             {
4133               listing_prev_line ();
4134               /* We may be at the start of a variant frag.  In case we
4135                  are, make sure there is enough space for the frag
4136                  after the frags created by listing_prev_line.  The
4137                  argument to frag_grow here must be at least as large
4138                  as the argument to all other calls to frag_grow in
4139                  this file.  We don't have to worry about being in the
4140                  middle of a variant frag, because the variants insert
4141                  all needed nop instructions themselves.  */
4142               frag_grow (40);
4143             }
4144
4145           mips_move_labels ();
4146
4147 #ifndef NO_ECOFF_DEBUGGING
4148           if (ECOFF_DEBUGGING)
4149             ecoff_fix_loc (old_frag, old_frag_offset);
4150 #endif
4151         }
4152     }
4153   else if (mips_relax.sequence != 2 && prev_nop_frag != NULL)
4154     {
4155       int nops;
4156
4157       /* Work out how many nops in prev_nop_frag are needed by IP,
4158          ignoring hazards generated by the first prev_nop_frag_since
4159          instructions.  */
4160       nops = nops_for_insn_or_target (prev_nop_frag_since, history, ip);
4161       gas_assert (nops <= prev_nop_frag_holds);
4162
4163       /* Enforce NOPS as a minimum.  */
4164       if (nops > prev_nop_frag_required)
4165         prev_nop_frag_required = nops;
4166
4167       if (prev_nop_frag_holds == prev_nop_frag_required)
4168         {
4169           /* Settle for the current number of nops.  Update the history
4170              accordingly (for the benefit of any future .set reorder code).  */
4171           prev_nop_frag = NULL;
4172           insert_into_history (prev_nop_frag_since,
4173                                prev_nop_frag_holds, NOP_INSN);
4174         }
4175       else
4176         {
4177           /* Allow this instruction to replace one of the nops that was
4178              tentatively added to prev_nop_frag.  */
4179           prev_nop_frag->fr_fix -= NOP_INSN_SIZE;
4180           prev_nop_frag_holds--;
4181           prev_nop_frag_since++;
4182         }
4183     }
4184
4185   method = get_append_method (ip);
4186   branch_disp = method == APPEND_SWAP ? insn_length (history) : 0;
4187
4188 #ifdef OBJ_ELF
4189   /* The value passed to dwarf2_emit_insn is the distance between
4190      the beginning of the current instruction and the address that
4191      should be recorded in the debug tables.  This is normally the
4192      current address.
4193
4194      For MIPS16/microMIPS debug info we want to use ISA-encoded
4195      addresses, so we use -1 for an address higher by one than the
4196      current one.
4197
4198      If the instruction produced is a branch that we will swap with
4199      the preceding instruction, then we add the displacement by which
4200      the branch will be moved backwards.  This is more appropriate
4201      and for MIPS16/microMIPS code also prevents a debugger from
4202      placing a breakpoint in the middle of the branch (and corrupting
4203      code if software breakpoints are used).  */
4204   dwarf2_emit_insn ((HAVE_CODE_COMPRESSION ? -1 : 0) + branch_disp);
4205 #endif
4206
4207   relax32 = (mips_relax_branch
4208              /* Don't try branch relaxation within .set nomacro, or within
4209                 .set noat if we use $at for PIC computations.  If it turns
4210                 out that the branch was out-of-range, we'll get an error.  */
4211              && !mips_opts.warn_about_macros
4212              && (mips_opts.at || mips_pic == NO_PIC)
4213              /* Don't relax BPOSGE32/64 as they have no complementing
4214                 branches.  */
4215              && !(ip->insn_mo->membership & (INSN_DSP64 | INSN_DSP)));
4216
4217   if (!HAVE_CODE_COMPRESSION
4218       && address_expr
4219       && relax32
4220       && *reloc_type == BFD_RELOC_16_PCREL_S2
4221       && delayed_branch_p (ip))
4222     {
4223       relaxed_branch = TRUE;
4224       add_relaxed_insn (ip, (relaxed_branch_length
4225                              (NULL, NULL,
4226                               uncond_branch_p (ip) ? -1
4227                               : branch_likely_p (ip) ? 1
4228                               : 0)), 4,
4229                         RELAX_BRANCH_ENCODE
4230                         (AT,
4231                          uncond_branch_p (ip),
4232                          branch_likely_p (ip),
4233                          pinfo & INSN_WRITE_GPR_31,
4234                          0),
4235                         address_expr->X_add_symbol,
4236                         address_expr->X_add_number);
4237       *reloc_type = BFD_RELOC_UNUSED;
4238     }
4239   else if (mips_opts.micromips
4240            && address_expr
4241            && ((relax32 && *reloc_type == BFD_RELOC_16_PCREL_S2)
4242                || *reloc_type > BFD_RELOC_UNUSED)
4243            && (delayed_branch_p (ip) || compact_branch_p (ip))
4244            /* Don't try branch relaxation when users specify
4245               16-bit/32-bit instructions.  */
4246            && !forced_insn_length)
4247     {
4248       bfd_boolean relax16 = *reloc_type > BFD_RELOC_UNUSED;
4249       int type = relax16 ? *reloc_type - BFD_RELOC_UNUSED : 0;
4250       int uncond = uncond_branch_p (ip) ? -1 : 0;
4251       int compact = compact_branch_p (ip);
4252       int al = pinfo & INSN_WRITE_GPR_31;
4253       int length32;
4254
4255       gas_assert (address_expr != NULL);
4256       gas_assert (!mips_relax.sequence);
4257
4258       relaxed_branch = TRUE;
4259       length32 = relaxed_micromips_32bit_branch_length (NULL, NULL, uncond);
4260       add_relaxed_insn (ip, relax32 ? length32 : 4, relax16 ? 2 : 4,
4261                         RELAX_MICROMIPS_ENCODE (type, AT, uncond, compact, al,
4262                                                 relax32, 0, 0),
4263                         address_expr->X_add_symbol,
4264                         address_expr->X_add_number);
4265       *reloc_type = BFD_RELOC_UNUSED;
4266     }
4267   else if (mips_opts.mips16 && *reloc_type > BFD_RELOC_UNUSED)
4268     {
4269       /* We need to set up a variant frag.  */
4270       gas_assert (address_expr != NULL);
4271       add_relaxed_insn (ip, 4, 0,
4272                         RELAX_MIPS16_ENCODE
4273                         (*reloc_type - BFD_RELOC_UNUSED,
4274                          forced_insn_length == 2, forced_insn_length == 4,
4275                          delayed_branch_p (&history[0]),
4276                          history[0].mips16_absolute_jump_p),
4277                         make_expr_symbol (address_expr), 0);
4278     }
4279   else if (mips_opts.mips16
4280            && ! ip->use_extend
4281            && *reloc_type != BFD_RELOC_MIPS16_JMP)
4282     {
4283       if (!delayed_branch_p (ip))
4284         /* Make sure there is enough room to swap this instruction with
4285            a following jump instruction.  */
4286         frag_grow (6);
4287       add_fixed_insn (ip);
4288     }
4289   else
4290     {
4291       if (mips_opts.mips16
4292           && mips_opts.noreorder
4293           && delayed_branch_p (&history[0]))
4294         as_warn (_("extended instruction in delay slot"));
4295
4296       if (mips_relax.sequence)
4297         {
4298           /* If we've reached the end of this frag, turn it into a variant
4299              frag and record the information for the instructions we've
4300              written so far.  */
4301           if (frag_room () < 4)
4302             relax_close_frag ();
4303           mips_relax.sizes[mips_relax.sequence - 1] += insn_length (ip);
4304         }
4305
4306       if (mips_relax.sequence != 2)
4307         {
4308           if (mips_macro_warning.first_insn_sizes[0] == 0)
4309             mips_macro_warning.first_insn_sizes[0] = insn_length (ip);
4310           mips_macro_warning.sizes[0] += insn_length (ip);
4311           mips_macro_warning.insns[0]++;
4312         }
4313       if (mips_relax.sequence != 1)
4314         {
4315           if (mips_macro_warning.first_insn_sizes[1] == 0)
4316             mips_macro_warning.first_insn_sizes[1] = insn_length (ip);
4317           mips_macro_warning.sizes[1] += insn_length (ip);
4318           mips_macro_warning.insns[1]++;
4319         }
4320
4321       if (mips_opts.mips16)
4322         {
4323           ip->fixed_p = 1;
4324           ip->mips16_absolute_jump_p = (*reloc_type == BFD_RELOC_MIPS16_JMP);
4325         }
4326       add_fixed_insn (ip);
4327     }
4328
4329   if (!ip->complete_p && *reloc_type < BFD_RELOC_UNUSED)
4330     {
4331       bfd_reloc_code_real_type final_type[3];
4332       reloc_howto_type *howto0;
4333       reloc_howto_type *howto;
4334       int i;
4335
4336       /* Perform any necessary conversion to microMIPS relocations
4337          and find out how many relocations there actually are.  */
4338       for (i = 0; i < 3 && reloc_type[i] != BFD_RELOC_UNUSED; i++)
4339         final_type[i] = micromips_map_reloc (reloc_type[i]);
4340
4341       /* In a compound relocation, it is the final (outermost)
4342          operator that determines the relocated field.  */
4343       howto = howto0 = bfd_reloc_type_lookup (stdoutput, final_type[i - 1]);
4344
4345       if (howto == NULL)
4346         {
4347           /* To reproduce this failure try assembling gas/testsuites/
4348              gas/mips/mips16-intermix.s with a mips-ecoff targeted
4349              assembler.  */
4350           as_bad (_("Unsupported MIPS relocation number %d"),
4351                   final_type[i - 1]);
4352           howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_16);
4353         }
4354
4355       if (i > 1)
4356         howto0 = bfd_reloc_type_lookup (stdoutput, final_type[0]);
4357       ip->fixp[0] = fix_new_exp (ip->frag, ip->where,
4358                                  bfd_get_reloc_size (howto),
4359                                  address_expr,
4360                                  howto0 && howto0->pc_relative,
4361                                  final_type[0]);
4362
4363       /* Tag symbols that have a R_MIPS16_26 relocation against them.  */
4364       if (final_type[0] == BFD_RELOC_MIPS16_JMP && ip->fixp[0]->fx_addsy)
4365         *symbol_get_tc (ip->fixp[0]->fx_addsy) = 1;
4366
4367       /* These relocations can have an addend that won't fit in
4368          4 octets for 64bit assembly.  */
4369       if (HAVE_64BIT_GPRS
4370           && ! howto->partial_inplace
4371           && (reloc_type[0] == BFD_RELOC_16
4372               || reloc_type[0] == BFD_RELOC_32
4373               || reloc_type[0] == BFD_RELOC_MIPS_JMP
4374               || reloc_type[0] == BFD_RELOC_GPREL16
4375               || reloc_type[0] == BFD_RELOC_MIPS_LITERAL
4376               || reloc_type[0] == BFD_RELOC_GPREL32
4377               || reloc_type[0] == BFD_RELOC_64
4378               || reloc_type[0] == BFD_RELOC_CTOR
4379               || reloc_type[0] == BFD_RELOC_MIPS_SUB
4380               || reloc_type[0] == BFD_RELOC_MIPS_HIGHEST
4381               || reloc_type[0] == BFD_RELOC_MIPS_HIGHER
4382               || reloc_type[0] == BFD_RELOC_MIPS_SCN_DISP
4383               || reloc_type[0] == BFD_RELOC_MIPS_REL16
4384               || reloc_type[0] == BFD_RELOC_MIPS_RELGOT
4385               || reloc_type[0] == BFD_RELOC_MIPS16_GPREL
4386               || hi16_reloc_p (reloc_type[0])
4387               || lo16_reloc_p (reloc_type[0])))
4388         ip->fixp[0]->fx_no_overflow = 1;
4389
4390       if (mips_relax.sequence)
4391         {
4392           if (mips_relax.first_fixup == 0)
4393             mips_relax.first_fixup = ip->fixp[0];
4394         }
4395       else if (reloc_needs_lo_p (*reloc_type))
4396         {
4397           struct mips_hi_fixup *hi_fixup;
4398
4399           /* Reuse the last entry if it already has a matching %lo.  */
4400           hi_fixup = mips_hi_fixup_list;
4401           if (hi_fixup == 0
4402               || !fixup_has_matching_lo_p (hi_fixup->fixp))
4403             {
4404               hi_fixup = ((struct mips_hi_fixup *)
4405                           xmalloc (sizeof (struct mips_hi_fixup)));
4406               hi_fixup->next = mips_hi_fixup_list;
4407               mips_hi_fixup_list = hi_fixup;
4408             }
4409           hi_fixup->fixp = ip->fixp[0];
4410           hi_fixup->seg = now_seg;
4411         }
4412
4413       /* Add fixups for the second and third relocations, if given.
4414          Note that the ABI allows the second relocation to be
4415          against RSS_UNDEF, RSS_GP, RSS_GP0 or RSS_LOC.  At the
4416          moment we only use RSS_UNDEF, but we could add support
4417          for the others if it ever becomes necessary.  */
4418       for (i = 1; i < 3; i++)
4419         if (reloc_type[i] != BFD_RELOC_UNUSED)
4420           {
4421             ip->fixp[i] = fix_new (ip->frag, ip->where,
4422                                    ip->fixp[0]->fx_size, NULL, 0,
4423                                    FALSE, final_type[i]);
4424
4425             /* Use fx_tcbit to mark compound relocs.  */
4426             ip->fixp[0]->fx_tcbit = 1;
4427             ip->fixp[i]->fx_tcbit = 1;
4428           }
4429     }
4430   install_insn (ip);
4431
4432   /* Update the register mask information.  */
4433   mips_gprmask |= gpr_read_mask (ip) | gpr_write_mask (ip);
4434   mips_cprmask[1] |= fpr_read_mask (ip) | fpr_write_mask (ip);
4435
4436   switch (method)
4437     {
4438     case APPEND_ADD:
4439       insert_into_history (0, 1, ip);
4440       break;
4441
4442     case APPEND_ADD_WITH_NOP:
4443       {
4444         struct mips_cl_insn *nop;
4445
4446         insert_into_history (0, 1, ip);
4447         nop = get_delay_slot_nop (ip);
4448         add_fixed_insn (nop);
4449         insert_into_history (0, 1, nop);
4450         if (mips_relax.sequence)
4451           mips_relax.sizes[mips_relax.sequence - 1] += insn_length (nop);
4452       }
4453       break;
4454
4455     case APPEND_ADD_COMPACT:
4456       /* Convert MIPS16 jr/jalr into a "compact" jump.  */
4457       gas_assert (mips_opts.mips16);
4458       ip->insn_opcode |= 0x0080;
4459       find_altered_mips16_opcode (ip);
4460       install_insn (ip);
4461       insert_into_history (0, 1, ip);
4462       break;
4463
4464     case APPEND_SWAP:
4465       {
4466         struct mips_cl_insn delay = history[0];
4467         if (mips_opts.mips16)
4468           {
4469             know (delay.frag == ip->frag);
4470             move_insn (ip, delay.frag, delay.where);
4471             move_insn (&delay, ip->frag, ip->where + insn_length (ip));
4472           }
4473         else if (relaxed_branch)
4474           {
4475             /* Add the delay slot instruction to the end of the
4476                current frag and shrink the fixed part of the
4477                original frag.  If the branch occupies the tail of
4478                the latter, move it backwards to cover the gap.  */
4479             delay.frag->fr_fix -= branch_disp;
4480             if (delay.frag == ip->frag)
4481               move_insn (ip, ip->frag, ip->where - branch_disp);
4482             add_fixed_insn (&delay);
4483           }
4484         else
4485           {
4486             move_insn (&delay, ip->frag,
4487                        ip->where - branch_disp + insn_length (ip));
4488             move_insn (ip, history[0].frag, history[0].where);
4489           }
4490         history[0] = *ip;
4491         delay.fixed_p = 1;
4492         insert_into_history (0, 1, &delay);
4493       }
4494       break;
4495     }
4496
4497   /* If we have just completed an unconditional branch, clear the history.  */
4498   if ((delayed_branch_p (&history[1]) && uncond_branch_p (&history[1]))
4499       || (compact_branch_p (&history[0]) && uncond_branch_p (&history[0])))
4500     mips_no_prev_insn ();
4501
4502   /* We need to emit a label at the end of branch-likely macros.  */
4503   if (emit_branch_likely_macro)
4504     {
4505       emit_branch_likely_macro = FALSE;
4506       micromips_add_label ();
4507     }
4508
4509   /* We just output an insn, so the next one doesn't have a label.  */
4510   mips_clear_insn_labels ();
4511 }
4512
4513 /* Forget that there was any previous instruction or label.  */
4514
4515 static void
4516 mips_no_prev_insn (void)
4517 {
4518   prev_nop_frag = NULL;
4519   insert_into_history (0, ARRAY_SIZE (history), NOP_INSN);
4520   mips_clear_insn_labels ();
4521 }
4522
4523 /* This function must be called before we emit something other than
4524    instructions.  It is like mips_no_prev_insn except that it inserts
4525    any NOPS that might be needed by previous instructions.  */
4526
4527 void
4528 mips_emit_delays (void)
4529 {
4530   if (! mips_opts.noreorder)
4531     {
4532       int nops = nops_for_insn (0, history, NULL);
4533       if (nops > 0)
4534         {
4535           while (nops-- > 0)
4536             add_fixed_insn (NOP_INSN);
4537           mips_move_labels ();
4538         }
4539     }
4540   mips_no_prev_insn ();
4541 }
4542
4543 /* Start a (possibly nested) noreorder block.  */
4544
4545 static void
4546 start_noreorder (void)
4547 {
4548   if (mips_opts.noreorder == 0)
4549     {
4550       unsigned int i;
4551       int nops;
4552
4553       /* None of the instructions before the .set noreorder can be moved.  */
4554       for (i = 0; i < ARRAY_SIZE (history); i++)
4555         history[i].fixed_p = 1;
4556
4557       /* Insert any nops that might be needed between the .set noreorder
4558          block and the previous instructions.  We will later remove any
4559          nops that turn out not to be needed.  */
4560       nops = nops_for_insn (0, history, NULL);
4561       if (nops > 0)
4562         {
4563           if (mips_optimize != 0)
4564             {
4565               /* Record the frag which holds the nop instructions, so
4566                  that we can remove them if we don't need them.  */
4567               frag_grow (nops * NOP_INSN_SIZE);
4568               prev_nop_frag = frag_now;
4569               prev_nop_frag_holds = nops;
4570               prev_nop_frag_required = 0;
4571               prev_nop_frag_since = 0;
4572             }
4573
4574           for (; nops > 0; --nops)
4575             add_fixed_insn (NOP_INSN);
4576
4577           /* Move on to a new frag, so that it is safe to simply
4578              decrease the size of prev_nop_frag.  */
4579           frag_wane (frag_now);
4580           frag_new (0);
4581           mips_move_labels ();
4582         }
4583       mips_mark_labels ();
4584       mips_clear_insn_labels ();
4585     }
4586   mips_opts.noreorder++;
4587   mips_any_noreorder = 1;
4588 }
4589
4590 /* End a nested noreorder block.  */
4591
4592 static void
4593 end_noreorder (void)
4594 {
4595   mips_opts.noreorder--;
4596   if (mips_opts.noreorder == 0 && prev_nop_frag != NULL)
4597     {
4598       /* Commit to inserting prev_nop_frag_required nops and go back to
4599          handling nop insertion the .set reorder way.  */
4600       prev_nop_frag->fr_fix -= ((prev_nop_frag_holds - prev_nop_frag_required)
4601                                 * NOP_INSN_SIZE);
4602       insert_into_history (prev_nop_frag_since,
4603                            prev_nop_frag_required, NOP_INSN);
4604       prev_nop_frag = NULL;
4605     }
4606 }
4607
4608 /* Set up global variables for the start of a new macro.  */
4609
4610 static void
4611 macro_start (void)
4612 {
4613   memset (&mips_macro_warning.sizes, 0, sizeof (mips_macro_warning.sizes));
4614   memset (&mips_macro_warning.first_insn_sizes, 0,
4615           sizeof (mips_macro_warning.first_insn_sizes));
4616   memset (&mips_macro_warning.insns, 0, sizeof (mips_macro_warning.insns));
4617   mips_macro_warning.delay_slot_p = (mips_opts.noreorder
4618                                      && delayed_branch_p (&history[0]));
4619   switch (history[0].insn_mo->pinfo2
4620           & (INSN2_BRANCH_DELAY_32BIT | INSN2_BRANCH_DELAY_16BIT))
4621     {
4622     case INSN2_BRANCH_DELAY_32BIT:
4623       mips_macro_warning.delay_slot_length = 4;
4624       break;
4625     case INSN2_BRANCH_DELAY_16BIT:
4626       mips_macro_warning.delay_slot_length = 2;
4627       break;
4628     default:
4629       mips_macro_warning.delay_slot_length = 0;
4630       break;
4631     }
4632   mips_macro_warning.first_frag = NULL;
4633 }
4634
4635 /* Given that a macro is longer than one instruction or of the wrong size,
4636    return the appropriate warning for it.  Return null if no warning is
4637    needed.  SUBTYPE is a bitmask of RELAX_DELAY_SLOT, RELAX_DELAY_SLOT_16BIT,
4638    RELAX_DELAY_SLOT_SIZE_FIRST, RELAX_DELAY_SLOT_SIZE_SECOND,
4639    and RELAX_NOMACRO.  */
4640
4641 static const char *
4642 macro_warning (relax_substateT subtype)
4643 {
4644   if (subtype & RELAX_DELAY_SLOT)
4645     return _("Macro instruction expanded into multiple instructions"
4646              " in a branch delay slot");
4647   else if (subtype & RELAX_NOMACRO)
4648     return _("Macro instruction expanded into multiple instructions");
4649   else if (subtype & (RELAX_DELAY_SLOT_SIZE_FIRST
4650                       | RELAX_DELAY_SLOT_SIZE_SECOND))
4651     return ((subtype & RELAX_DELAY_SLOT_16BIT)
4652             ? _("Macro instruction expanded into a wrong size instruction"
4653                 " in a 16-bit branch delay slot")
4654             : _("Macro instruction expanded into a wrong size instruction"
4655                 " in a 32-bit branch delay slot"));
4656   else
4657     return 0;
4658 }
4659
4660 /* Finish up a macro.  Emit warnings as appropriate.  */
4661
4662 static void
4663 macro_end (void)
4664 {
4665   /* Relaxation warning flags.  */
4666   relax_substateT subtype = 0;
4667
4668   /* Check delay slot size requirements.  */
4669   if (mips_macro_warning.delay_slot_length == 2)
4670     subtype |= RELAX_DELAY_SLOT_16BIT;
4671   if (mips_macro_warning.delay_slot_length != 0)
4672     {
4673       if (mips_macro_warning.delay_slot_length
4674           != mips_macro_warning.first_insn_sizes[0])
4675         subtype |= RELAX_DELAY_SLOT_SIZE_FIRST;
4676       if (mips_macro_warning.delay_slot_length
4677           != mips_macro_warning.first_insn_sizes[1])
4678         subtype |= RELAX_DELAY_SLOT_SIZE_SECOND;
4679     }
4680
4681   /* Check instruction count requirements.  */
4682   if (mips_macro_warning.insns[0] > 1 || mips_macro_warning.insns[1] > 1)
4683     {
4684       if (mips_macro_warning.insns[1] > mips_macro_warning.insns[0])
4685         subtype |= RELAX_SECOND_LONGER;
4686       if (mips_opts.warn_about_macros)
4687         subtype |= RELAX_NOMACRO;
4688       if (mips_macro_warning.delay_slot_p)
4689         subtype |= RELAX_DELAY_SLOT;
4690     }
4691
4692   /* If both alternatives fail to fill a delay slot correctly,
4693      emit the warning now.  */
4694   if ((subtype & RELAX_DELAY_SLOT_SIZE_FIRST) != 0
4695       && (subtype & RELAX_DELAY_SLOT_SIZE_SECOND) != 0)
4696     {
4697       relax_substateT s;
4698       const char *msg;
4699
4700       s = subtype & (RELAX_DELAY_SLOT_16BIT
4701                      | RELAX_DELAY_SLOT_SIZE_FIRST
4702                      | RELAX_DELAY_SLOT_SIZE_SECOND);
4703       msg = macro_warning (s);
4704       if (msg != NULL)
4705         as_warn ("%s", msg);
4706       subtype &= ~s;
4707     }
4708
4709   /* If both implementations are longer than 1 instruction, then emit the
4710      warning now.  */
4711   if (mips_macro_warning.insns[0] > 1 && mips_macro_warning.insns[1] > 1)
4712     {
4713       relax_substateT s;
4714       const char *msg;
4715
4716       s = subtype & (RELAX_SECOND_LONGER | RELAX_NOMACRO | RELAX_DELAY_SLOT);
4717       msg = macro_warning (s);
4718       if (msg != NULL)
4719         as_warn ("%s", msg);
4720       subtype &= ~s;
4721     }
4722
4723   /* If any flags still set, then one implementation might need a warning
4724      and the other either will need one of a different kind or none at all.
4725      Pass any remaining flags over to relaxation.  */
4726   if (mips_macro_warning.first_frag != NULL)
4727     mips_macro_warning.first_frag->fr_subtype |= subtype;
4728 }
4729
4730 /* Instruction operand formats used in macros that vary between
4731    standard MIPS and microMIPS code.  */
4732
4733 static const char * const brk_fmt[2] = { "c", "mF" };
4734 static const char * const cop12_fmt[2] = { "E,o(b)", "E,~(b)" };
4735 static const char * const jalr_fmt[2] = { "d,s", "t,s" };
4736 static const char * const lui_fmt[2] = { "t,u", "s,u" };
4737 static const char * const mem12_fmt[2] = { "t,o(b)", "t,~(b)" };
4738 static const char * const mfhl_fmt[2] = { "d", "mj" };
4739 static const char * const shft_fmt[2] = { "d,w,<", "t,r,<" };
4740 static const char * const trap_fmt[2] = { "s,t,q", "s,t,|" };
4741
4742 #define BRK_FMT (brk_fmt[mips_opts.micromips])
4743 #define COP12_FMT (cop12_fmt[mips_opts.micromips])
4744 #define JALR_FMT (jalr_fmt[mips_opts.micromips])
4745 #define LUI_FMT (lui_fmt[mips_opts.micromips])
4746 #define MEM12_FMT (mem12_fmt[mips_opts.micromips])
4747 #define MFHL_FMT (mfhl_fmt[mips_opts.micromips])
4748 #define SHFT_FMT (shft_fmt[mips_opts.micromips])
4749 #define TRAP_FMT (trap_fmt[mips_opts.micromips])
4750
4751 /* Read a macro's relocation codes from *ARGS and store them in *R.
4752    The first argument in *ARGS will be either the code for a single
4753    relocation or -1 followed by the three codes that make up a
4754    composite relocation.  */
4755
4756 static void
4757 macro_read_relocs (va_list *args, bfd_reloc_code_real_type *r)
4758 {
4759   int i, next;
4760
4761   next = va_arg (*args, int);
4762   if (next >= 0)
4763     r[0] = (bfd_reloc_code_real_type) next;
4764   else
4765     for (i = 0; i < 3; i++)
4766       r[i] = (bfd_reloc_code_real_type) va_arg (*args, int);
4767 }
4768
4769 /* Build an instruction created by a macro expansion.  This is passed
4770    a pointer to the count of instructions created so far, an
4771    expression, the name of the instruction to build, an operand format
4772    string, and corresponding arguments.  */
4773
4774 static void
4775 macro_build (expressionS *ep, const char *name, const char *fmt, ...)
4776 {
4777   const struct mips_opcode *mo = NULL;
4778   bfd_reloc_code_real_type r[3];
4779   const struct mips_opcode *amo;
4780   struct hash_control *hash;
4781   struct mips_cl_insn insn;
4782   va_list args;
4783
4784   va_start (args, fmt);
4785
4786   if (mips_opts.mips16)
4787     {
4788       mips16_macro_build (ep, name, fmt, &args);
4789       va_end (args);
4790       return;
4791     }
4792
4793   r[0] = BFD_RELOC_UNUSED;
4794   r[1] = BFD_RELOC_UNUSED;
4795   r[2] = BFD_RELOC_UNUSED;
4796   hash = mips_opts.micromips ? micromips_op_hash : op_hash;
4797   amo = (struct mips_opcode *) hash_find (hash, name);
4798   gas_assert (amo);
4799   gas_assert (strcmp (name, amo->name) == 0);
4800
4801   do
4802     {
4803       /* Search until we get a match for NAME.  It is assumed here that
4804          macros will never generate MDMX, MIPS-3D, or MT instructions.
4805          We try to match an instruction that fulfils the branch delay
4806          slot instruction length requirement (if any) of the previous
4807          instruction.  While doing this we record the first instruction
4808          seen that matches all the other conditions and use it anyway
4809          if the requirement cannot be met; we will issue an appropriate
4810          warning later on.  */
4811       if (strcmp (fmt, amo->args) == 0
4812           && amo->pinfo != INSN_MACRO
4813           && is_opcode_valid (amo)
4814           && is_size_valid (amo))
4815         {
4816           if (is_delay_slot_valid (amo))
4817             {
4818               mo = amo;
4819               break;
4820             }
4821           else if (!mo)
4822             mo = amo;
4823         }
4824
4825       ++amo;
4826       gas_assert (amo->name);
4827     }
4828   while (strcmp (name, amo->name) == 0);
4829
4830   gas_assert (mo);
4831   create_insn (&insn, mo);
4832   for (;;)
4833     {
4834       switch (*fmt++)
4835         {
4836         case '\0':
4837           break;
4838
4839         case ',':
4840         case '(':
4841         case ')':
4842           continue;
4843
4844         case '+':
4845           switch (*fmt++)
4846             {
4847             case 'A':
4848             case 'E':
4849               INSERT_OPERAND (mips_opts.micromips,
4850                               EXTLSB, insn, va_arg (args, int));
4851               continue;
4852
4853             case 'B':
4854             case 'F':
4855               /* Note that in the macro case, these arguments are already
4856                  in MSB form.  (When handling the instruction in the
4857                  non-macro case, these arguments are sizes from which
4858                  MSB values must be calculated.)  */
4859               INSERT_OPERAND (mips_opts.micromips,
4860                               INSMSB, insn, va_arg (args, int));
4861               continue;
4862
4863             case 'C':
4864             case 'G':
4865             case 'H':
4866               /* Note that in the macro case, these arguments are already
4867                  in MSBD form.  (When handling the instruction in the
4868                  non-macro case, these arguments are sizes from which
4869                  MSBD values must be calculated.)  */
4870               INSERT_OPERAND (mips_opts.micromips,
4871                               EXTMSBD, insn, va_arg (args, int));
4872               continue;
4873
4874             case 'Q':
4875               gas_assert (!mips_opts.micromips);
4876               INSERT_OPERAND (0, SEQI, insn, va_arg (args, int));
4877               continue;
4878
4879             default:
4880               internalError ();
4881             }
4882           continue;
4883
4884         case '2':
4885           gas_assert (!mips_opts.micromips);
4886           INSERT_OPERAND (0, BP, insn, va_arg (args, int));
4887           continue;
4888
4889         case 'n':
4890           gas_assert (mips_opts.micromips);
4891         case 't':
4892         case 'w':
4893         case 'E':
4894           INSERT_OPERAND (mips_opts.micromips, RT, insn, va_arg (args, int));
4895           continue;
4896
4897         case 'c':
4898           gas_assert (!mips_opts.micromips);
4899           INSERT_OPERAND (0, CODE, insn, va_arg (args, int));
4900           continue;
4901
4902         case 'W':
4903           gas_assert (!mips_opts.micromips);
4904         case 'T':
4905           INSERT_OPERAND (mips_opts.micromips, FT, insn, va_arg (args, int));
4906           continue;
4907
4908         case 'G':
4909           if (mips_opts.micromips)
4910             INSERT_OPERAND (1, RS, insn, va_arg (args, int));
4911           else
4912             INSERT_OPERAND (0, RD, insn, va_arg (args, int));
4913           continue;
4914
4915         case 'K':
4916           gas_assert (!mips_opts.micromips);
4917         case 'd':
4918           INSERT_OPERAND (mips_opts.micromips, RD, insn, va_arg (args, int));
4919           continue;
4920
4921         case 'U':
4922           gas_assert (!mips_opts.micromips);
4923           {
4924             int tmp = va_arg (args, int);
4925
4926             INSERT_OPERAND (0, RT, insn, tmp);
4927             INSERT_OPERAND (0, RD, insn, tmp);
4928           }
4929           continue;
4930
4931         case 'V':
4932         case 'S':
4933           gas_assert (!mips_opts.micromips);
4934           INSERT_OPERAND (0, FS, insn, va_arg (args, int));
4935           continue;
4936
4937         case 'z':
4938           continue;
4939
4940         case '<':
4941           INSERT_OPERAND (mips_opts.micromips,
4942                           SHAMT, insn, va_arg (args, int));
4943           continue;
4944
4945         case 'D':
4946           gas_assert (!mips_opts.micromips);
4947           INSERT_OPERAND (0, FD, insn, va_arg (args, int));
4948           continue;
4949
4950         case 'B':
4951           gas_assert (!mips_opts.micromips);
4952           INSERT_OPERAND (0, CODE20, insn, va_arg (args, int));
4953           continue;
4954
4955         case 'J':
4956           gas_assert (!mips_opts.micromips);
4957           INSERT_OPERAND (0, CODE19, insn, va_arg (args, int));
4958           continue;
4959
4960         case 'q':
4961           gas_assert (!mips_opts.micromips);
4962           INSERT_OPERAND (0, CODE2, insn, va_arg (args, int));
4963           continue;
4964
4965         case 'b':
4966         case 's':
4967         case 'r':
4968         case 'v':
4969           INSERT_OPERAND (mips_opts.micromips, RS, insn, va_arg (args, int));
4970           continue;
4971
4972         case 'i':
4973         case 'j':
4974           macro_read_relocs (&args, r);
4975           gas_assert (*r == BFD_RELOC_GPREL16
4976                       || *r == BFD_RELOC_MIPS_HIGHER
4977                       || *r == BFD_RELOC_HI16_S
4978                       || *r == BFD_RELOC_LO16
4979                       || *r == BFD_RELOC_MIPS_GOT_OFST);
4980           continue;
4981
4982         case 'o':
4983           macro_read_relocs (&args, r);
4984           continue;
4985
4986         case 'u':
4987           macro_read_relocs (&args, r);
4988           gas_assert (ep != NULL
4989                       && (ep->X_op == O_constant
4990                           || (ep->X_op == O_symbol
4991                               && (*r == BFD_RELOC_MIPS_HIGHEST
4992                                   || *r == BFD_RELOC_HI16_S
4993                                   || *r == BFD_RELOC_HI16
4994                                   || *r == BFD_RELOC_GPREL16
4995                                   || *r == BFD_RELOC_MIPS_GOT_HI16
4996                                   || *r == BFD_RELOC_MIPS_CALL_HI16))));
4997           continue;
4998
4999         case 'p':
5000           gas_assert (ep != NULL);
5001
5002           /*
5003            * This allows macro() to pass an immediate expression for
5004            * creating short branches without creating a symbol.
5005            *
5006            * We don't allow branch relaxation for these branches, as
5007            * they should only appear in ".set nomacro" anyway.
5008            */
5009           if (ep->X_op == O_constant)
5010             {
5011               /* For microMIPS we always use relocations for branches.
5012                  So we should not resolve immediate values.  */
5013               gas_assert (!mips_opts.micromips);
5014
5015               if ((ep->X_add_number & 3) != 0)
5016                 as_bad (_("branch to misaligned address (0x%lx)"),
5017                         (unsigned long) ep->X_add_number);
5018               if ((ep->X_add_number + 0x20000) & ~0x3ffff)
5019                 as_bad (_("branch address range overflow (0x%lx)"),
5020                         (unsigned long) ep->X_add_number);
5021               insn.insn_opcode |= (ep->X_add_number >> 2) & 0xffff;
5022               ep = NULL;
5023             }
5024           else
5025             *r = BFD_RELOC_16_PCREL_S2;
5026           continue;
5027
5028         case 'a':
5029           gas_assert (ep != NULL);
5030           *r = BFD_RELOC_MIPS_JMP;
5031           continue;
5032
5033         case 'C':
5034           gas_assert (!mips_opts.micromips);
5035           INSERT_OPERAND (0, COPZ, insn, va_arg (args, unsigned long));
5036           continue;
5037
5038         case 'k':
5039           INSERT_OPERAND (mips_opts.micromips,
5040                           CACHE, insn, va_arg (args, unsigned long));
5041           continue;
5042
5043         case '|':
5044           gas_assert (mips_opts.micromips);
5045           INSERT_OPERAND (1, TRAP, insn, va_arg (args, int));
5046           continue;
5047
5048         case '.':
5049           gas_assert (mips_opts.micromips);
5050           INSERT_OPERAND (1, OFFSET10, insn, va_arg (args, int));
5051           continue;
5052
5053         case '\\':
5054           INSERT_OPERAND (mips_opts.micromips,
5055                           3BITPOS, insn, va_arg (args, unsigned int));
5056           continue;
5057
5058         case '~':
5059           INSERT_OPERAND (mips_opts.micromips,
5060                           OFFSET12, insn, va_arg (args, unsigned long));
5061           continue;
5062
5063         case 'N':
5064           gas_assert (mips_opts.micromips);
5065           INSERT_OPERAND (1, BCC, insn, va_arg (args, int));
5066           continue;
5067
5068         case 'm':       /* Opcode extension character.  */
5069           gas_assert (mips_opts.micromips);
5070           switch (*fmt++)
5071             {
5072             case 'j':
5073               INSERT_OPERAND (1, MJ, insn, va_arg (args, int));
5074               break;
5075
5076             case 'p':
5077               INSERT_OPERAND (1, MP, insn, va_arg (args, int));
5078               break;
5079
5080             case 'F':
5081               INSERT_OPERAND (1, IMMF, insn, va_arg (args, int));
5082               break;
5083
5084             default:
5085               internalError ();
5086             }
5087           continue;
5088
5089         default:
5090           internalError ();
5091         }
5092       break;
5093     }
5094   va_end (args);
5095   gas_assert (*r == BFD_RELOC_UNUSED ? ep == NULL : ep != NULL);
5096
5097   append_insn (&insn, ep, r, TRUE);
5098 }
5099
5100 static void
5101 mips16_macro_build (expressionS *ep, const char *name, const char *fmt,
5102                     va_list *args)
5103 {
5104   struct mips_opcode *mo;
5105   struct mips_cl_insn insn;
5106   bfd_reloc_code_real_type r[3]
5107     = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
5108
5109   mo = (struct mips_opcode *) hash_find (mips16_op_hash, name);
5110   gas_assert (mo);
5111   gas_assert (strcmp (name, mo->name) == 0);
5112
5113   while (strcmp (fmt, mo->args) != 0 || mo->pinfo == INSN_MACRO)
5114     {
5115       ++mo;
5116       gas_assert (mo->name);
5117       gas_assert (strcmp (name, mo->name) == 0);
5118     }
5119
5120   create_insn (&insn, mo);
5121   for (;;)
5122     {
5123       int c;
5124
5125       c = *fmt++;
5126       switch (c)
5127         {
5128         case '\0':
5129           break;
5130
5131         case ',':
5132         case '(':
5133         case ')':
5134           continue;
5135
5136         case 'y':
5137         case 'w':
5138           MIPS16_INSERT_OPERAND (RY, insn, va_arg (*args, int));
5139           continue;
5140
5141         case 'x':
5142         case 'v':
5143           MIPS16_INSERT_OPERAND (RX, insn, va_arg (*args, int));
5144           continue;
5145
5146         case 'z':
5147           MIPS16_INSERT_OPERAND (RZ, insn, va_arg (*args, int));
5148           continue;
5149
5150         case 'Z':
5151           MIPS16_INSERT_OPERAND (MOVE32Z, insn, va_arg (*args, int));
5152           continue;
5153
5154         case '0':
5155         case 'S':
5156         case 'P':
5157         case 'R':
5158           continue;
5159
5160         case 'X':
5161           MIPS16_INSERT_OPERAND (REGR32, insn, va_arg (*args, int));
5162           continue;
5163
5164         case 'Y':
5165           {
5166             int regno;
5167
5168             regno = va_arg (*args, int);
5169             regno = ((regno & 7) << 2) | ((regno & 0x18) >> 3);
5170             MIPS16_INSERT_OPERAND (REG32R, insn, regno);
5171           }
5172           continue;
5173
5174         case '<':
5175         case '>':
5176         case '4':
5177         case '5':
5178         case 'H':
5179         case 'W':
5180         case 'D':
5181         case 'j':
5182         case '8':
5183         case 'V':
5184         case 'C':
5185         case 'U':
5186         case 'k':
5187         case 'K':
5188         case 'p':
5189         case 'q':
5190           {
5191             gas_assert (ep != NULL);
5192
5193             if (ep->X_op != O_constant)
5194               *r = (int) BFD_RELOC_UNUSED + c;
5195             else
5196               {
5197                 mips16_immed (NULL, 0, c, ep->X_add_number, FALSE, FALSE,
5198                               FALSE, &insn.insn_opcode, &insn.use_extend,
5199                               &insn.extend);
5200                 ep = NULL;
5201                 *r = BFD_RELOC_UNUSED;
5202               }
5203           }
5204           continue;
5205
5206         case '6':
5207           MIPS16_INSERT_OPERAND (IMM6, insn, va_arg (*args, int));
5208           continue;
5209         }
5210
5211       break;
5212     }
5213
5214   gas_assert (*r == BFD_RELOC_UNUSED ? ep == NULL : ep != NULL);
5215
5216   append_insn (&insn, ep, r, TRUE);
5217 }
5218
5219 /*
5220  * Sign-extend 32-bit mode constants that have bit 31 set and all
5221  * higher bits unset.
5222  */
5223 static void
5224 normalize_constant_expr (expressionS *ex)
5225 {
5226   if (ex->X_op == O_constant
5227       && IS_ZEXT_32BIT_NUM (ex->X_add_number))
5228     ex->X_add_number = (((ex->X_add_number & 0xffffffff) ^ 0x80000000)
5229                         - 0x80000000);
5230 }
5231
5232 /*
5233  * Sign-extend 32-bit mode address offsets that have bit 31 set and
5234  * all higher bits unset.
5235  */
5236 static void
5237 normalize_address_expr (expressionS *ex)
5238 {
5239   if (((ex->X_op == O_constant && HAVE_32BIT_ADDRESSES)
5240         || (ex->X_op == O_symbol && HAVE_32BIT_SYMBOLS))
5241       && IS_ZEXT_32BIT_NUM (ex->X_add_number))
5242     ex->X_add_number = (((ex->X_add_number & 0xffffffff) ^ 0x80000000)
5243                         - 0x80000000);
5244 }
5245
5246 /*
5247  * Generate a "jalr" instruction with a relocation hint to the called
5248  * function.  This occurs in NewABI PIC code.
5249  */
5250 static void
5251 macro_build_jalr (expressionS *ep, int cprestore)
5252 {
5253   static const bfd_reloc_code_real_type jalr_relocs[2]
5254     = { BFD_RELOC_MIPS_JALR, BFD_RELOC_MICROMIPS_JALR };
5255   bfd_reloc_code_real_type jalr_reloc = jalr_relocs[mips_opts.micromips];
5256   const char *jalr;
5257   char *f = NULL;
5258
5259   if (MIPS_JALR_HINT_P (ep))
5260     {
5261       frag_grow (8);
5262       f = frag_more (0);
5263     }
5264   if (mips_opts.micromips)
5265     {
5266       jalr = mips_opts.noreorder && !cprestore ? "jalr" : "jalrs";
5267       if (MIPS_JALR_HINT_P (ep))
5268         macro_build (NULL, jalr, "t,s", RA, PIC_CALL_REG);
5269       else
5270         macro_build (NULL, jalr, "mj", PIC_CALL_REG);
5271     }
5272   else
5273     macro_build (NULL, "jalr", "d,s", RA, PIC_CALL_REG);
5274   if (MIPS_JALR_HINT_P (ep))
5275     fix_new_exp (frag_now, f - frag_now->fr_literal, 4, ep, FALSE, jalr_reloc);
5276 }
5277
5278 /*
5279  * Generate a "lui" instruction.
5280  */
5281 static void
5282 macro_build_lui (expressionS *ep, int regnum)
5283 {
5284   gas_assert (! mips_opts.mips16);
5285
5286   if (ep->X_op != O_constant)
5287     {
5288       gas_assert (ep->X_op == O_symbol);
5289       /* _gp_disp is a special case, used from s_cpload.
5290          __gnu_local_gp is used if mips_no_shared.  */
5291       gas_assert (mips_pic == NO_PIC
5292               || (! HAVE_NEWABI
5293                   && strcmp (S_GET_NAME (ep->X_add_symbol), "_gp_disp") == 0)
5294               || (! mips_in_shared
5295                   && strcmp (S_GET_NAME (ep->X_add_symbol),
5296                              "__gnu_local_gp") == 0));
5297     }
5298
5299   macro_build (ep, "lui", LUI_FMT, regnum, BFD_RELOC_HI16_S);
5300 }
5301
5302 /* Generate a sequence of instructions to do a load or store from a constant
5303    offset off of a base register (breg) into/from a target register (treg),
5304    using AT if necessary.  */
5305 static void
5306 macro_build_ldst_constoffset (expressionS *ep, const char *op,
5307                               int treg, int breg, int dbl)
5308 {
5309   gas_assert (ep->X_op == O_constant);
5310
5311   /* Sign-extending 32-bit constants makes their handling easier.  */
5312   if (!dbl)
5313     normalize_constant_expr (ep);
5314
5315   /* Right now, this routine can only handle signed 32-bit constants.  */
5316   if (! IS_SEXT_32BIT_NUM(ep->X_add_number + 0x8000))
5317     as_warn (_("operand overflow"));
5318
5319   if (IS_SEXT_16BIT_NUM(ep->X_add_number))
5320     {
5321       /* Signed 16-bit offset will fit in the op.  Easy!  */
5322       macro_build (ep, op, "t,o(b)", treg, BFD_RELOC_LO16, breg);
5323     }
5324   else
5325     {
5326       /* 32-bit offset, need multiple instructions and AT, like:
5327            lui      $tempreg,const_hi       (BFD_RELOC_HI16_S)
5328            addu     $tempreg,$tempreg,$breg
5329            <op>     $treg,const_lo($tempreg)   (BFD_RELOC_LO16)
5330          to handle the complete offset.  */
5331       macro_build_lui (ep, AT);
5332       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, AT, breg);
5333       macro_build (ep, op, "t,o(b)", treg, BFD_RELOC_LO16, AT);
5334
5335       if (!mips_opts.at)
5336         as_bad (_("Macro used $at after \".set noat\""));
5337     }
5338 }
5339
5340 /*                      set_at()
5341  * Generates code to set the $at register to true (one)
5342  * if reg is less than the immediate expression.
5343  */
5344 static void
5345 set_at (int reg, int unsignedp)
5346 {
5347   if (imm_expr.X_op == O_constant
5348       && imm_expr.X_add_number >= -0x8000
5349       && imm_expr.X_add_number < 0x8000)
5350     macro_build (&imm_expr, unsignedp ? "sltiu" : "slti", "t,r,j",
5351                  AT, reg, BFD_RELOC_LO16);
5352   else
5353     {
5354       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
5355       macro_build (NULL, unsignedp ? "sltu" : "slt", "d,v,t", AT, reg, AT);
5356     }
5357 }
5358
5359 /* Warn if an expression is not a constant.  */
5360
5361 static void
5362 check_absolute_expr (struct mips_cl_insn *ip, expressionS *ex)
5363 {
5364   if (ex->X_op == O_big)
5365     as_bad (_("unsupported large constant"));
5366   else if (ex->X_op != O_constant)
5367     as_bad (_("Instruction %s requires absolute expression"),
5368             ip->insn_mo->name);
5369
5370   if (HAVE_32BIT_GPRS)
5371     normalize_constant_expr (ex);
5372 }
5373
5374 /* Count the leading zeroes by performing a binary chop. This is a
5375    bulky bit of source, but performance is a LOT better for the
5376    majority of values than a simple loop to count the bits:
5377        for (lcnt = 0; (lcnt < 32); lcnt++)
5378          if ((v) & (1 << (31 - lcnt)))
5379            break;
5380   However it is not code size friendly, and the gain will drop a bit
5381   on certain cached systems.
5382 */
5383 #define COUNT_TOP_ZEROES(v)             \
5384   (((v) & ~0xffff) == 0                 \
5385    ? ((v) & ~0xff) == 0                 \
5386      ? ((v) & ~0xf) == 0                \
5387        ? ((v) & ~0x3) == 0              \
5388          ? ((v) & ~0x1) == 0            \
5389            ? !(v)                       \
5390              ? 32                       \
5391              : 31                       \
5392            : 30                         \
5393          : ((v) & ~0x7) == 0            \
5394            ? 29                         \
5395            : 28                         \
5396        : ((v) & ~0x3f) == 0             \
5397          ? ((v) & ~0x1f) == 0           \
5398            ? 27                         \
5399            : 26                         \
5400          : ((v) & ~0x7f) == 0           \
5401            ? 25                         \
5402            : 24                         \
5403      : ((v) & ~0xfff) == 0              \
5404        ? ((v) & ~0x3ff) == 0            \
5405          ? ((v) & ~0x1ff) == 0          \
5406            ? 23                         \
5407            : 22                         \
5408          : ((v) & ~0x7ff) == 0          \
5409            ? 21                         \
5410            : 20                         \
5411        : ((v) & ~0x3fff) == 0           \
5412          ? ((v) & ~0x1fff) == 0         \
5413            ? 19                         \
5414            : 18                         \
5415          : ((v) & ~0x7fff) == 0         \
5416            ? 17                         \
5417            : 16                         \
5418    : ((v) & ~0xffffff) == 0             \
5419      ? ((v) & ~0xfffff) == 0            \
5420        ? ((v) & ~0x3ffff) == 0          \
5421          ? ((v) & ~0x1ffff) == 0        \
5422            ? 15                         \
5423            : 14                         \
5424          : ((v) & ~0x7ffff) == 0        \
5425            ? 13                         \
5426            : 12                         \
5427        : ((v) & ~0x3fffff) == 0         \
5428          ? ((v) & ~0x1fffff) == 0       \
5429            ? 11                         \
5430            : 10                         \
5431          : ((v) & ~0x7fffff) == 0       \
5432            ? 9                          \
5433            : 8                          \
5434      : ((v) & ~0xfffffff) == 0          \
5435        ? ((v) & ~0x3ffffff) == 0        \
5436          ? ((v) & ~0x1ffffff) == 0      \
5437            ? 7                          \
5438            : 6                          \
5439          : ((v) & ~0x7ffffff) == 0      \
5440            ? 5                          \
5441            : 4                          \
5442        : ((v) & ~0x3fffffff) == 0       \
5443          ? ((v) & ~0x1fffffff) == 0     \
5444            ? 3                          \
5445            : 2                          \
5446          : ((v) & ~0x7fffffff) == 0     \
5447            ? 1                          \
5448            : 0)
5449
5450 /*                      load_register()
5451  *  This routine generates the least number of instructions necessary to load
5452  *  an absolute expression value into a register.
5453  */
5454 static void
5455 load_register (int reg, expressionS *ep, int dbl)
5456 {
5457   int freg;
5458   expressionS hi32, lo32;
5459
5460   if (ep->X_op != O_big)
5461     {
5462       gas_assert (ep->X_op == O_constant);
5463
5464       /* Sign-extending 32-bit constants makes their handling easier.  */
5465       if (!dbl)
5466         normalize_constant_expr (ep);
5467
5468       if (IS_SEXT_16BIT_NUM (ep->X_add_number))
5469         {
5470           /* We can handle 16 bit signed values with an addiu to
5471              $zero.  No need to ever use daddiu here, since $zero and
5472              the result are always correct in 32 bit mode.  */
5473           macro_build (ep, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
5474           return;
5475         }
5476       else if (ep->X_add_number >= 0 && ep->X_add_number < 0x10000)
5477         {
5478           /* We can handle 16 bit unsigned values with an ori to
5479              $zero.  */
5480           macro_build (ep, "ori", "t,r,i", reg, 0, BFD_RELOC_LO16);
5481           return;
5482         }
5483       else if ((IS_SEXT_32BIT_NUM (ep->X_add_number)))
5484         {
5485           /* 32 bit values require an lui.  */
5486           macro_build (ep, "lui", LUI_FMT, reg, BFD_RELOC_HI16);
5487           if ((ep->X_add_number & 0xffff) != 0)
5488             macro_build (ep, "ori", "t,r,i", reg, reg, BFD_RELOC_LO16);
5489           return;
5490         }
5491     }
5492
5493   /* The value is larger than 32 bits.  */
5494
5495   if (!dbl || HAVE_32BIT_GPRS)
5496     {
5497       char value[32];
5498
5499       sprintf_vma (value, ep->X_add_number);
5500       as_bad (_("Number (0x%s) larger than 32 bits"), value);
5501       macro_build (ep, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
5502       return;
5503     }
5504
5505   if (ep->X_op != O_big)
5506     {
5507       hi32 = *ep;
5508       hi32.X_add_number = (valueT) hi32.X_add_number >> 16;
5509       hi32.X_add_number = (valueT) hi32.X_add_number >> 16;
5510       hi32.X_add_number &= 0xffffffff;
5511       lo32 = *ep;
5512       lo32.X_add_number &= 0xffffffff;
5513     }
5514   else
5515     {
5516       gas_assert (ep->X_add_number > 2);
5517       if (ep->X_add_number == 3)
5518         generic_bignum[3] = 0;
5519       else if (ep->X_add_number > 4)
5520         as_bad (_("Number larger than 64 bits"));
5521       lo32.X_op = O_constant;
5522       lo32.X_add_number = generic_bignum[0] + (generic_bignum[1] << 16);
5523       hi32.X_op = O_constant;
5524       hi32.X_add_number = generic_bignum[2] + (generic_bignum[3] << 16);
5525     }
5526
5527   if (hi32.X_add_number == 0)
5528     freg = 0;
5529   else
5530     {
5531       int shift, bit;
5532       unsigned long hi, lo;
5533
5534       if (hi32.X_add_number == (offsetT) 0xffffffff)
5535         {
5536           if ((lo32.X_add_number & 0xffff8000) == 0xffff8000)
5537             {
5538               macro_build (&lo32, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
5539               return;
5540             }
5541           if (lo32.X_add_number & 0x80000000)
5542             {
5543               macro_build (&lo32, "lui", LUI_FMT, reg, BFD_RELOC_HI16);
5544               if (lo32.X_add_number & 0xffff)
5545                 macro_build (&lo32, "ori", "t,r,i", reg, reg, BFD_RELOC_LO16);
5546               return;
5547             }
5548         }
5549
5550       /* Check for 16bit shifted constant.  We know that hi32 is
5551          non-zero, so start the mask on the first bit of the hi32
5552          value.  */
5553       shift = 17;
5554       do
5555         {
5556           unsigned long himask, lomask;
5557
5558           if (shift < 32)
5559             {
5560               himask = 0xffff >> (32 - shift);
5561               lomask = (0xffff << shift) & 0xffffffff;
5562             }
5563           else
5564             {
5565               himask = 0xffff << (shift - 32);
5566               lomask = 0;
5567             }
5568           if ((hi32.X_add_number & ~(offsetT) himask) == 0
5569               && (lo32.X_add_number & ~(offsetT) lomask) == 0)
5570             {
5571               expressionS tmp;
5572
5573               tmp.X_op = O_constant;
5574               if (shift < 32)
5575                 tmp.X_add_number = ((hi32.X_add_number << (32 - shift))
5576                                     | (lo32.X_add_number >> shift));
5577               else
5578                 tmp.X_add_number = hi32.X_add_number >> (shift - 32);
5579               macro_build (&tmp, "ori", "t,r,i", reg, 0, BFD_RELOC_LO16);
5580               macro_build (NULL, (shift >= 32) ? "dsll32" : "dsll", SHFT_FMT,
5581                            reg, reg, (shift >= 32) ? shift - 32 : shift);
5582               return;
5583             }
5584           ++shift;
5585         }
5586       while (shift <= (64 - 16));
5587
5588       /* Find the bit number of the lowest one bit, and store the
5589          shifted value in hi/lo.  */
5590       hi = (unsigned long) (hi32.X_add_number & 0xffffffff);
5591       lo = (unsigned long) (lo32.X_add_number & 0xffffffff);
5592       if (lo != 0)
5593         {
5594           bit = 0;
5595           while ((lo & 1) == 0)
5596             {
5597               lo >>= 1;
5598               ++bit;
5599             }
5600           lo |= (hi & (((unsigned long) 1 << bit) - 1)) << (32 - bit);
5601           hi >>= bit;
5602         }
5603       else
5604         {
5605           bit = 32;
5606           while ((hi & 1) == 0)
5607             {
5608               hi >>= 1;
5609               ++bit;
5610             }
5611           lo = hi;
5612           hi = 0;
5613         }
5614
5615       /* Optimize if the shifted value is a (power of 2) - 1.  */
5616       if ((hi == 0 && ((lo + 1) & lo) == 0)
5617           || (lo == 0xffffffff && ((hi + 1) & hi) == 0))
5618         {
5619           shift = COUNT_TOP_ZEROES ((unsigned int) hi32.X_add_number);
5620           if (shift != 0)
5621             {
5622               expressionS tmp;
5623
5624               /* This instruction will set the register to be all
5625                  ones.  */
5626               tmp.X_op = O_constant;
5627               tmp.X_add_number = (offsetT) -1;
5628               macro_build (&tmp, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
5629               if (bit != 0)
5630                 {
5631                   bit += shift;
5632                   macro_build (NULL, (bit >= 32) ? "dsll32" : "dsll", SHFT_FMT,
5633                                reg, reg, (bit >= 32) ? bit - 32 : bit);
5634                 }
5635               macro_build (NULL, (shift >= 32) ? "dsrl32" : "dsrl", SHFT_FMT,
5636                            reg, reg, (shift >= 32) ? shift - 32 : shift);
5637               return;
5638             }
5639         }
5640
5641       /* Sign extend hi32 before calling load_register, because we can
5642          generally get better code when we load a sign extended value.  */
5643       if ((hi32.X_add_number & 0x80000000) != 0)
5644         hi32.X_add_number |= ~(offsetT) 0xffffffff;
5645       load_register (reg, &hi32, 0);
5646       freg = reg;
5647     }
5648   if ((lo32.X_add_number & 0xffff0000) == 0)
5649     {
5650       if (freg != 0)
5651         {
5652           macro_build (NULL, "dsll32", SHFT_FMT, reg, freg, 0);
5653           freg = reg;
5654         }
5655     }
5656   else
5657     {
5658       expressionS mid16;
5659
5660       if ((freg == 0) && (lo32.X_add_number == (offsetT) 0xffffffff))
5661         {
5662           macro_build (&lo32, "lui", LUI_FMT, reg, BFD_RELOC_HI16);
5663           macro_build (NULL, "dsrl32", SHFT_FMT, reg, reg, 0);
5664           return;
5665         }
5666
5667       if (freg != 0)
5668         {
5669           macro_build (NULL, "dsll", SHFT_FMT, reg, freg, 16);
5670           freg = reg;
5671         }
5672       mid16 = lo32;
5673       mid16.X_add_number >>= 16;
5674       macro_build (&mid16, "ori", "t,r,i", reg, freg, BFD_RELOC_LO16);
5675       macro_build (NULL, "dsll", SHFT_FMT, reg, reg, 16);
5676       freg = reg;
5677     }
5678   if ((lo32.X_add_number & 0xffff) != 0)
5679     macro_build (&lo32, "ori", "t,r,i", reg, freg, BFD_RELOC_LO16);
5680 }
5681
5682 static inline void
5683 load_delay_nop (void)
5684 {
5685   if (!gpr_interlocks)
5686     macro_build (NULL, "nop", "");
5687 }
5688
5689 /* Load an address into a register.  */
5690
5691 static void
5692 load_address (int reg, expressionS *ep, int *used_at)
5693 {
5694   if (ep->X_op != O_constant
5695       && ep->X_op != O_symbol)
5696     {
5697       as_bad (_("expression too complex"));
5698       ep->X_op = O_constant;
5699     }
5700
5701   if (ep->X_op == O_constant)
5702     {
5703       load_register (reg, ep, HAVE_64BIT_ADDRESSES);
5704       return;
5705     }
5706
5707   if (mips_pic == NO_PIC)
5708     {
5709       /* If this is a reference to a GP relative symbol, we want
5710            addiu        $reg,$gp,<sym>          (BFD_RELOC_GPREL16)
5711          Otherwise we want
5712            lui          $reg,<sym>              (BFD_RELOC_HI16_S)
5713            addiu        $reg,$reg,<sym>         (BFD_RELOC_LO16)
5714          If we have an addend, we always use the latter form.
5715
5716          With 64bit address space and a usable $at we want
5717            lui          $reg,<sym>              (BFD_RELOC_MIPS_HIGHEST)
5718            lui          $at,<sym>               (BFD_RELOC_HI16_S)
5719            daddiu       $reg,<sym>              (BFD_RELOC_MIPS_HIGHER)
5720            daddiu       $at,<sym>               (BFD_RELOC_LO16)
5721            dsll32       $reg,0
5722            daddu        $reg,$reg,$at
5723
5724          If $at is already in use, we use a path which is suboptimal
5725          on superscalar processors.
5726            lui          $reg,<sym>              (BFD_RELOC_MIPS_HIGHEST)
5727            daddiu       $reg,<sym>              (BFD_RELOC_MIPS_HIGHER)
5728            dsll         $reg,16
5729            daddiu       $reg,<sym>              (BFD_RELOC_HI16_S)
5730            dsll         $reg,16
5731            daddiu       $reg,<sym>              (BFD_RELOC_LO16)
5732
5733          For GP relative symbols in 64bit address space we can use
5734          the same sequence as in 32bit address space.  */
5735       if (HAVE_64BIT_SYMBOLS)
5736         {
5737           if ((valueT) ep->X_add_number <= MAX_GPREL_OFFSET
5738               && !nopic_need_relax (ep->X_add_symbol, 1))
5739             {
5740               relax_start (ep->X_add_symbol);
5741               macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg,
5742                            mips_gp_register, BFD_RELOC_GPREL16);
5743               relax_switch ();
5744             }
5745
5746           if (*used_at == 0 && mips_opts.at)
5747             {
5748               macro_build (ep, "lui", LUI_FMT, reg, BFD_RELOC_MIPS_HIGHEST);
5749               macro_build (ep, "lui", LUI_FMT, AT, BFD_RELOC_HI16_S);
5750               macro_build (ep, "daddiu", "t,r,j", reg, reg,
5751                            BFD_RELOC_MIPS_HIGHER);
5752               macro_build (ep, "daddiu", "t,r,j", AT, AT, BFD_RELOC_LO16);
5753               macro_build (NULL, "dsll32", SHFT_FMT, reg, reg, 0);
5754               macro_build (NULL, "daddu", "d,v,t", reg, reg, AT);
5755               *used_at = 1;
5756             }
5757           else
5758             {
5759               macro_build (ep, "lui", LUI_FMT, reg, BFD_RELOC_MIPS_HIGHEST);
5760               macro_build (ep, "daddiu", "t,r,j", reg, reg,
5761                            BFD_RELOC_MIPS_HIGHER);
5762               macro_build (NULL, "dsll", SHFT_FMT, reg, reg, 16);
5763               macro_build (ep, "daddiu", "t,r,j", reg, reg, BFD_RELOC_HI16_S);
5764               macro_build (NULL, "dsll", SHFT_FMT, reg, reg, 16);
5765               macro_build (ep, "daddiu", "t,r,j", reg, reg, BFD_RELOC_LO16);
5766             }
5767
5768           if (mips_relax.sequence)
5769             relax_end ();
5770         }
5771       else
5772         {
5773           if ((valueT) ep->X_add_number <= MAX_GPREL_OFFSET
5774               && !nopic_need_relax (ep->X_add_symbol, 1))
5775             {
5776               relax_start (ep->X_add_symbol);
5777               macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg,
5778                            mips_gp_register, BFD_RELOC_GPREL16);
5779               relax_switch ();
5780             }
5781           macro_build_lui (ep, reg);
5782           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j",
5783                        reg, reg, BFD_RELOC_LO16);
5784           if (mips_relax.sequence)
5785             relax_end ();
5786         }
5787     }
5788   else if (!mips_big_got)
5789     {
5790       expressionS ex;
5791
5792       /* If this is a reference to an external symbol, we want
5793            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT16)
5794          Otherwise we want
5795            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT16)
5796            nop
5797            addiu        $reg,$reg,<sym>         (BFD_RELOC_LO16)
5798          If there is a constant, it must be added in after.
5799
5800          If we have NewABI, we want
5801            lw           $reg,<sym+cst>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
5802          unless we're referencing a global symbol with a non-zero
5803          offset, in which case cst must be added separately.  */
5804       if (HAVE_NEWABI)
5805         {
5806           if (ep->X_add_number)
5807             {
5808               ex.X_add_number = ep->X_add_number;
5809               ep->X_add_number = 0;
5810               relax_start (ep->X_add_symbol);
5811               macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
5812                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
5813               if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
5814                 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
5815               ex.X_op = O_constant;
5816               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j",
5817                            reg, reg, BFD_RELOC_LO16);
5818               ep->X_add_number = ex.X_add_number;
5819               relax_switch ();
5820             }
5821           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
5822                        BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
5823           if (mips_relax.sequence)
5824             relax_end ();
5825         }
5826       else
5827         {
5828           ex.X_add_number = ep->X_add_number;
5829           ep->X_add_number = 0;
5830           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
5831                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
5832           load_delay_nop ();
5833           relax_start (ep->X_add_symbol);
5834           relax_switch ();
5835           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
5836                        BFD_RELOC_LO16);
5837           relax_end ();
5838
5839           if (ex.X_add_number != 0)
5840             {
5841               if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
5842                 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
5843               ex.X_op = O_constant;
5844               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j",
5845                            reg, reg, BFD_RELOC_LO16);
5846             }
5847         }
5848     }
5849   else if (mips_big_got)
5850     {
5851       expressionS ex;
5852
5853       /* This is the large GOT case.  If this is a reference to an
5854          external symbol, we want
5855            lui          $reg,<sym>              (BFD_RELOC_MIPS_GOT_HI16)
5856            addu         $reg,$reg,$gp
5857            lw           $reg,<sym>($reg)        (BFD_RELOC_MIPS_GOT_LO16)
5858
5859          Otherwise, for a reference to a local symbol in old ABI, we want
5860            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT16)
5861            nop
5862            addiu        $reg,$reg,<sym>         (BFD_RELOC_LO16)
5863          If there is a constant, it must be added in after.
5864
5865          In the NewABI, for local symbols, with or without offsets, we want:
5866            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT_PAGE)
5867            addiu        $reg,$reg,<sym>         (BFD_RELOC_MIPS_GOT_OFST)
5868       */
5869       if (HAVE_NEWABI)
5870         {
5871           ex.X_add_number = ep->X_add_number;
5872           ep->X_add_number = 0;
5873           relax_start (ep->X_add_symbol);
5874           macro_build (ep, "lui", LUI_FMT, reg, BFD_RELOC_MIPS_GOT_HI16);
5875           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5876                        reg, reg, mips_gp_register);
5877           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)",
5878                        reg, BFD_RELOC_MIPS_GOT_LO16, reg);
5879           if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
5880             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
5881           else if (ex.X_add_number)
5882             {
5883               ex.X_op = O_constant;
5884               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
5885                            BFD_RELOC_LO16);
5886             }
5887
5888           ep->X_add_number = ex.X_add_number;
5889           relax_switch ();
5890           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
5891                        BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
5892           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
5893                        BFD_RELOC_MIPS_GOT_OFST);
5894           relax_end ();
5895         }
5896       else
5897         {
5898           ex.X_add_number = ep->X_add_number;
5899           ep->X_add_number = 0;
5900           relax_start (ep->X_add_symbol);
5901           macro_build (ep, "lui", LUI_FMT, reg, BFD_RELOC_MIPS_GOT_HI16);
5902           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5903                        reg, reg, mips_gp_register);
5904           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)",
5905                        reg, BFD_RELOC_MIPS_GOT_LO16, reg);
5906           relax_switch ();
5907           if (reg_needs_delay (mips_gp_register))
5908             {
5909               /* We need a nop before loading from $gp.  This special
5910                  check is required because the lui which starts the main
5911                  instruction stream does not refer to $gp, and so will not
5912                  insert the nop which may be required.  */
5913               macro_build (NULL, "nop", "");
5914             }
5915           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
5916                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
5917           load_delay_nop ();
5918           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
5919                        BFD_RELOC_LO16);
5920           relax_end ();
5921
5922           if (ex.X_add_number != 0)
5923             {
5924               if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
5925                 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
5926               ex.X_op = O_constant;
5927               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
5928                            BFD_RELOC_LO16);
5929             }
5930         }
5931     }
5932   else
5933     abort ();
5934
5935   if (!mips_opts.at && *used_at == 1)
5936     as_bad (_("Macro used $at after \".set noat\""));
5937 }
5938
5939 /* Move the contents of register SOURCE into register DEST.  */
5940
5941 static void
5942 move_register (int dest, int source)
5943 {
5944   /* Prefer to use a 16-bit microMIPS instruction unless the previous
5945      instruction specifically requires a 32-bit one.  */
5946   if (mips_opts.micromips
5947       && !(history[0].insn_mo->pinfo2 & INSN2_BRANCH_DELAY_32BIT))
5948     macro_build (NULL, "move", "mp,mj", dest, source);
5949   else
5950     macro_build (NULL, HAVE_32BIT_GPRS ? "addu" : "daddu", "d,v,t",
5951                  dest, source, 0);
5952 }
5953
5954 /* Emit an SVR4 PIC sequence to load address LOCAL into DEST, where
5955    LOCAL is the sum of a symbol and a 16-bit or 32-bit displacement.
5956    The two alternatives are:
5957
5958    Global symbol                Local sybmol
5959    -------------                ------------
5960    lw DEST,%got(SYMBOL)         lw DEST,%got(SYMBOL + OFFSET)
5961    ...                          ...
5962    addiu DEST,DEST,OFFSET       addiu DEST,DEST,%lo(SYMBOL + OFFSET)
5963
5964    load_got_offset emits the first instruction and add_got_offset
5965    emits the second for a 16-bit offset or add_got_offset_hilo emits
5966    a sequence to add a 32-bit offset using a scratch register.  */
5967
5968 static void
5969 load_got_offset (int dest, expressionS *local)
5970 {
5971   expressionS global;
5972
5973   global = *local;
5974   global.X_add_number = 0;
5975
5976   relax_start (local->X_add_symbol);
5977   macro_build (&global, ADDRESS_LOAD_INSN, "t,o(b)", dest,
5978                BFD_RELOC_MIPS_GOT16, mips_gp_register);
5979   relax_switch ();
5980   macro_build (local, ADDRESS_LOAD_INSN, "t,o(b)", dest,
5981                BFD_RELOC_MIPS_GOT16, mips_gp_register);
5982   relax_end ();
5983 }
5984
5985 static void
5986 add_got_offset (int dest, expressionS *local)
5987 {
5988   expressionS global;
5989
5990   global.X_op = O_constant;
5991   global.X_op_symbol = NULL;
5992   global.X_add_symbol = NULL;
5993   global.X_add_number = local->X_add_number;
5994
5995   relax_start (local->X_add_symbol);
5996   macro_build (&global, ADDRESS_ADDI_INSN, "t,r,j",
5997                dest, dest, BFD_RELOC_LO16);
5998   relax_switch ();
5999   macro_build (local, ADDRESS_ADDI_INSN, "t,r,j", dest, dest, BFD_RELOC_LO16);
6000   relax_end ();
6001 }
6002
6003 static void
6004 add_got_offset_hilo (int dest, expressionS *local, int tmp)
6005 {
6006   expressionS global;
6007   int hold_mips_optimize;
6008
6009   global.X_op = O_constant;
6010   global.X_op_symbol = NULL;
6011   global.X_add_symbol = NULL;
6012   global.X_add_number = local->X_add_number;
6013
6014   relax_start (local->X_add_symbol);
6015   load_register (tmp, &global, HAVE_64BIT_ADDRESSES);
6016   relax_switch ();
6017   /* Set mips_optimize around the lui instruction to avoid
6018      inserting an unnecessary nop after the lw.  */
6019   hold_mips_optimize = mips_optimize;
6020   mips_optimize = 2;
6021   macro_build_lui (&global, tmp);
6022   mips_optimize = hold_mips_optimize;
6023   macro_build (local, ADDRESS_ADDI_INSN, "t,r,j", tmp, tmp, BFD_RELOC_LO16);
6024   relax_end ();
6025
6026   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", dest, dest, tmp);
6027 }
6028
6029 /* Emit a sequence of instructions to emulate a branch likely operation.
6030    BR is an ordinary branch corresponding to one to be emulated.  BRNEG
6031    is its complementing branch with the original condition negated.
6032    CALL is set if the original branch specified the link operation.
6033    EP, FMT, SREG and TREG specify the usual macro_build() parameters.
6034
6035    Code like this is produced in the noreorder mode:
6036
6037         BRNEG   <args>, 1f
6038          nop
6039         b       <sym>
6040          delay slot (executed only if branch taken)
6041     1:
6042
6043    or, if CALL is set:
6044
6045         BRNEG   <args>, 1f
6046          nop
6047         bal     <sym>
6048          delay slot (executed only if branch taken)
6049     1:
6050
6051    In the reorder mode the delay slot would be filled with a nop anyway,
6052    so code produced is simply:
6053
6054         BR      <args>, <sym>
6055          nop
6056
6057    This function is used when producing code for the microMIPS ASE that
6058    does not implement branch likely instructions in hardware.  */
6059
6060 static void
6061 macro_build_branch_likely (const char *br, const char *brneg,
6062                            int call, expressionS *ep, const char *fmt,
6063                            unsigned int sreg, unsigned int treg)
6064 {
6065   int noreorder = mips_opts.noreorder;
6066   expressionS expr1;
6067
6068   gas_assert (mips_opts.micromips);
6069   start_noreorder ();
6070   if (noreorder)
6071     {
6072       micromips_label_expr (&expr1);
6073       macro_build (&expr1, brneg, fmt, sreg, treg);
6074       macro_build (NULL, "nop", "");
6075       macro_build (ep, call ? "bal" : "b", "p");
6076
6077       /* Set to true so that append_insn adds a label.  */
6078       emit_branch_likely_macro = TRUE;
6079     }
6080   else
6081     {
6082       macro_build (ep, br, fmt, sreg, treg);
6083       macro_build (NULL, "nop", "");
6084     }
6085   end_noreorder ();
6086 }
6087
6088 /* Emit a coprocessor branch-likely macro specified by TYPE, using CC as
6089    the condition code tested.  EP specifies the branch target.  */
6090
6091 static void
6092 macro_build_branch_ccl (int type, expressionS *ep, unsigned int cc)
6093 {
6094   const int call = 0;
6095   const char *brneg;
6096   const char *br;
6097
6098   switch (type)
6099     {
6100     case M_BC1FL:
6101       br = "bc1f";
6102       brneg = "bc1t";
6103       break;
6104     case M_BC1TL:
6105       br = "bc1t";
6106       brneg = "bc1f";
6107       break;
6108     case M_BC2FL:
6109       br = "bc2f";
6110       brneg = "bc2t";
6111       break;
6112     case M_BC2TL:
6113       br = "bc2t";
6114       brneg = "bc2f";
6115       break;
6116     default:
6117       abort ();
6118     }
6119   macro_build_branch_likely (br, brneg, call, ep, "N,p", cc, ZERO);
6120 }
6121
6122 /* Emit a two-argument branch macro specified by TYPE, using SREG as
6123    the register tested.  EP specifies the branch target.  */
6124
6125 static void
6126 macro_build_branch_rs (int type, expressionS *ep, unsigned int sreg)
6127 {
6128   const char *brneg = NULL;
6129   const char *br;
6130   int call = 0;
6131
6132   switch (type)
6133     {
6134     case M_BGEZ:
6135       br = "bgez";
6136       break;
6137     case M_BGEZL:
6138       br = mips_opts.micromips ? "bgez" : "bgezl";
6139       brneg = "bltz";
6140       break;
6141     case M_BGEZALL:
6142       gas_assert (mips_opts.micromips);
6143       br = "bgezals";
6144       brneg = "bltz";
6145       call = 1;
6146       break;
6147     case M_BGTZ:
6148       br = "bgtz";
6149       break;
6150     case M_BGTZL:
6151       br = mips_opts.micromips ? "bgtz" : "bgtzl";
6152       brneg = "blez";
6153       break;
6154     case M_BLEZ:
6155       br = "blez";
6156       break;
6157     case M_BLEZL:
6158       br = mips_opts.micromips ? "blez" : "blezl";
6159       brneg = "bgtz";
6160       break;
6161     case M_BLTZ:
6162       br = "bltz";
6163       break;
6164     case M_BLTZL:
6165       br = mips_opts.micromips ? "bltz" : "bltzl";
6166       brneg = "bgez";
6167       break;
6168     case M_BLTZALL:
6169       gas_assert (mips_opts.micromips);
6170       br = "bltzals";
6171       brneg = "bgez";
6172       call = 1;
6173       break;
6174     default:
6175       abort ();
6176     }
6177   if (mips_opts.micromips && brneg)
6178     macro_build_branch_likely (br, brneg, call, ep, "s,p", sreg, ZERO);
6179   else
6180     macro_build (ep, br, "s,p", sreg);
6181 }
6182
6183 /* Emit a three-argument branch macro specified by TYPE, using SREG and
6184    TREG as the registers tested.  EP specifies the branch target.  */
6185
6186 static void
6187 macro_build_branch_rsrt (int type, expressionS *ep,
6188                          unsigned int sreg, unsigned int treg)
6189 {
6190   const char *brneg = NULL;
6191   const int call = 0;
6192   const char *br;
6193
6194   switch (type)
6195     {
6196     case M_BEQ:
6197     case M_BEQ_I:
6198       br = "beq";
6199       break;
6200     case M_BEQL:
6201     case M_BEQL_I:
6202       br = mips_opts.micromips ? "beq" : "beql";
6203       brneg = "bne";
6204       break;
6205     case M_BNE:
6206     case M_BNE_I:
6207       br = "bne";
6208       break;
6209     case M_BNEL:
6210     case M_BNEL_I:
6211       br = mips_opts.micromips ? "bne" : "bnel";
6212       brneg = "beq";
6213       break;
6214     default:
6215       abort ();
6216     }
6217   if (mips_opts.micromips && brneg)
6218     macro_build_branch_likely (br, brneg, call, ep, "s,t,p", sreg, treg);
6219   else
6220     macro_build (ep, br, "s,t,p", sreg, treg);
6221 }
6222
6223 /*
6224  *                      Build macros
6225  *   This routine implements the seemingly endless macro or synthesized
6226  * instructions and addressing modes in the mips assembly language. Many
6227  * of these macros are simple and are similar to each other. These could
6228  * probably be handled by some kind of table or grammar approach instead of
6229  * this verbose method. Others are not simple macros but are more like
6230  * optimizing code generation.
6231  *   One interesting optimization is when several store macros appear
6232  * consecutively that would load AT with the upper half of the same address.
6233  * The ensuing load upper instructions are ommited. This implies some kind
6234  * of global optimization. We currently only optimize within a single macro.
6235  *   For many of the load and store macros if the address is specified as a
6236  * constant expression in the first 64k of memory (ie ld $2,0x4000c) we
6237  * first load register 'at' with zero and use it as the base register. The
6238  * mips assembler simply uses register $zero. Just one tiny optimization
6239  * we're missing.
6240  */
6241 static void
6242 macro (struct mips_cl_insn *ip)
6243 {
6244   unsigned int treg, sreg, dreg, breg;
6245   unsigned int tempreg;
6246   int mask;
6247   int used_at = 0;
6248   expressionS label_expr;
6249   expressionS expr1;
6250   expressionS *ep;
6251   const char *s;
6252   const char *s2;
6253   const char *fmt;
6254   int likely = 0;
6255   int coproc = 0;
6256   int off12 = 0;
6257   int call = 0;
6258   int jals = 0;
6259   int dbl = 0;
6260   int imm = 0;
6261   int ust = 0;
6262   int lp = 0;
6263   int ab = 0;
6264   int off;
6265   offsetT maxnum;
6266   bfd_reloc_code_real_type r;
6267   int hold_mips_optimize;
6268
6269   gas_assert (! mips_opts.mips16);
6270
6271   treg = EXTRACT_OPERAND (mips_opts.micromips, RT, *ip);
6272   dreg = EXTRACT_OPERAND (mips_opts.micromips, RD, *ip);
6273   sreg = breg = EXTRACT_OPERAND (mips_opts.micromips, RS, *ip);
6274   mask = ip->insn_mo->mask;
6275
6276   label_expr.X_op = O_constant;
6277   label_expr.X_op_symbol = NULL;
6278   label_expr.X_add_symbol = NULL;
6279   label_expr.X_add_number = 0;
6280
6281   expr1.X_op = O_constant;
6282   expr1.X_op_symbol = NULL;
6283   expr1.X_add_symbol = NULL;
6284   expr1.X_add_number = 1;
6285
6286   switch (mask)
6287     {
6288     case M_DABS:
6289       dbl = 1;
6290     case M_ABS:
6291       /*    bgez    $a0,1f
6292             move    v0,$a0
6293             sub     v0,$zero,$a0
6294          1:
6295        */
6296
6297       start_noreorder ();
6298
6299       if (mips_opts.micromips)
6300         micromips_label_expr (&label_expr);
6301       else
6302         label_expr.X_add_number = 8;
6303       macro_build (&label_expr, "bgez", "s,p", sreg);
6304       if (dreg == sreg)
6305         macro_build (NULL, "nop", "");
6306       else
6307         move_register (dreg, sreg);
6308       macro_build (NULL, dbl ? "dsub" : "sub", "d,v,t", dreg, 0, sreg);
6309       if (mips_opts.micromips)
6310         micromips_add_label ();
6311
6312       end_noreorder ();
6313       break;
6314
6315     case M_ADD_I:
6316       s = "addi";
6317       s2 = "add";
6318       goto do_addi;
6319     case M_ADDU_I:
6320       s = "addiu";
6321       s2 = "addu";
6322       goto do_addi;
6323     case M_DADD_I:
6324       dbl = 1;
6325       s = "daddi";
6326       s2 = "dadd";
6327       if (!mips_opts.micromips)
6328         goto do_addi;
6329       if (imm_expr.X_op == O_constant
6330           && imm_expr.X_add_number >= -0x200
6331           && imm_expr.X_add_number < 0x200)
6332         {
6333           macro_build (NULL, s, "t,r,.", treg, sreg, imm_expr.X_add_number);
6334           break;
6335         }
6336       goto do_addi_i;
6337     case M_DADDU_I:
6338       dbl = 1;
6339       s = "daddiu";
6340       s2 = "daddu";
6341     do_addi:
6342       if (imm_expr.X_op == O_constant
6343           && imm_expr.X_add_number >= -0x8000
6344           && imm_expr.X_add_number < 0x8000)
6345         {
6346           macro_build (&imm_expr, s, "t,r,j", treg, sreg, BFD_RELOC_LO16);
6347           break;
6348         }
6349     do_addi_i:
6350       used_at = 1;
6351       load_register (AT, &imm_expr, dbl);
6352       macro_build (NULL, s2, "d,v,t", treg, sreg, AT);
6353       break;
6354
6355     case M_AND_I:
6356       s = "andi";
6357       s2 = "and";
6358       goto do_bit;
6359     case M_OR_I:
6360       s = "ori";
6361       s2 = "or";
6362       goto do_bit;
6363     case M_NOR_I:
6364       s = "";
6365       s2 = "nor";
6366       goto do_bit;
6367     case M_XOR_I:
6368       s = "xori";
6369       s2 = "xor";
6370     do_bit:
6371       if (imm_expr.X_op == O_constant
6372           && imm_expr.X_add_number >= 0
6373           && imm_expr.X_add_number < 0x10000)
6374         {
6375           if (mask != M_NOR_I)
6376             macro_build (&imm_expr, s, "t,r,i", treg, sreg, BFD_RELOC_LO16);
6377           else
6378             {
6379               macro_build (&imm_expr, "ori", "t,r,i",
6380                            treg, sreg, BFD_RELOC_LO16);
6381               macro_build (NULL, "nor", "d,v,t", treg, treg, 0);
6382             }
6383           break;
6384         }
6385
6386       used_at = 1;
6387       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
6388       macro_build (NULL, s2, "d,v,t", treg, sreg, AT);
6389       break;
6390
6391     case M_BALIGN:
6392       switch (imm_expr.X_add_number)
6393         {
6394         case 0:
6395           macro_build (NULL, "nop", "");
6396           break;
6397         case 2:
6398           macro_build (NULL, "packrl.ph", "d,s,t", treg, treg, sreg);
6399           break;
6400         default:
6401           macro_build (NULL, "balign", "t,s,2", treg, sreg,
6402                        (int) imm_expr.X_add_number);
6403           break;
6404         }
6405       break;
6406
6407     case M_BC1FL:
6408     case M_BC1TL:
6409     case M_BC2FL:
6410     case M_BC2TL:
6411       gas_assert (mips_opts.micromips);
6412       macro_build_branch_ccl (mask, &offset_expr,
6413                               EXTRACT_OPERAND (1, BCC, *ip));
6414       break;
6415
6416     case M_BEQ_I:
6417     case M_BEQL_I:
6418     case M_BNE_I:
6419     case M_BNEL_I:
6420       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
6421         treg = 0;
6422       else
6423         {
6424           treg = AT;
6425           used_at = 1;
6426           load_register (treg, &imm_expr, HAVE_64BIT_GPRS);
6427         }
6428       /* Fall through.  */
6429     case M_BEQL:
6430     case M_BNEL:
6431       macro_build_branch_rsrt (mask, &offset_expr, sreg, treg);
6432       break;
6433
6434     case M_BGEL:
6435       likely = 1;
6436     case M_BGE:
6437       if (treg == 0)
6438         macro_build_branch_rs (likely ? M_BGEZL : M_BGEZ, &offset_expr, sreg);
6439       else if (sreg == 0)
6440         macro_build_branch_rs (likely ? M_BLEZL : M_BLEZ, &offset_expr, treg);
6441       else
6442         {
6443           used_at = 1;
6444           macro_build (NULL, "slt", "d,v,t", AT, sreg, treg);
6445           macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6446                                    &offset_expr, AT, ZERO);
6447         }
6448       break;
6449
6450     case M_BGEZL:
6451     case M_BGEZALL:
6452     case M_BGTZL:
6453     case M_BLEZL:
6454     case M_BLTZL:
6455     case M_BLTZALL:
6456       macro_build_branch_rs (mask, &offset_expr, sreg);
6457       break;
6458
6459     case M_BGTL_I:
6460       likely = 1;
6461     case M_BGT_I:
6462       /* Check for > max integer.  */
6463       maxnum = 0x7fffffff;
6464       if (HAVE_64BIT_GPRS && sizeof (maxnum) > 4)
6465         {
6466           maxnum <<= 16;
6467           maxnum |= 0xffff;
6468           maxnum <<= 16;
6469           maxnum |= 0xffff;
6470         }
6471       if (imm_expr.X_op == O_constant
6472           && imm_expr.X_add_number >= maxnum
6473           && (HAVE_32BIT_GPRS || sizeof (maxnum) > 4))
6474         {
6475         do_false:
6476           /* Result is always false.  */
6477           if (! likely)
6478             macro_build (NULL, "nop", "");
6479           else
6480             macro_build_branch_rsrt (M_BNEL, &offset_expr, ZERO, ZERO);
6481           break;
6482         }
6483       if (imm_expr.X_op != O_constant)
6484         as_bad (_("Unsupported large constant"));
6485       ++imm_expr.X_add_number;
6486       /* FALLTHROUGH */
6487     case M_BGE_I:
6488     case M_BGEL_I:
6489       if (mask == M_BGEL_I)
6490         likely = 1;
6491       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
6492         {
6493           macro_build_branch_rs (likely ? M_BGEZL : M_BGEZ,
6494                                  &offset_expr, sreg);
6495           break;
6496         }
6497       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
6498         {
6499           macro_build_branch_rs (likely ? M_BGTZL : M_BGTZ,
6500                                  &offset_expr, sreg);
6501           break;
6502         }
6503       maxnum = 0x7fffffff;
6504       if (HAVE_64BIT_GPRS && sizeof (maxnum) > 4)
6505         {
6506           maxnum <<= 16;
6507           maxnum |= 0xffff;
6508           maxnum <<= 16;
6509           maxnum |= 0xffff;
6510         }
6511       maxnum = - maxnum - 1;
6512       if (imm_expr.X_op == O_constant
6513           && imm_expr.X_add_number <= maxnum
6514           && (HAVE_32BIT_GPRS || sizeof (maxnum) > 4))
6515         {
6516         do_true:
6517           /* result is always true */
6518           as_warn (_("Branch %s is always true"), ip->insn_mo->name);
6519           macro_build (&offset_expr, "b", "p");
6520           break;
6521         }
6522       used_at = 1;
6523       set_at (sreg, 0);
6524       macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6525                                &offset_expr, AT, ZERO);
6526       break;
6527
6528     case M_BGEUL:
6529       likely = 1;
6530     case M_BGEU:
6531       if (treg == 0)
6532         goto do_true;
6533       else if (sreg == 0)
6534         macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6535                                  &offset_expr, ZERO, treg);
6536       else
6537         {
6538           used_at = 1;
6539           macro_build (NULL, "sltu", "d,v,t", AT, sreg, treg);
6540           macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6541                                    &offset_expr, AT, ZERO);
6542         }
6543       break;
6544
6545     case M_BGTUL_I:
6546       likely = 1;
6547     case M_BGTU_I:
6548       if (sreg == 0
6549           || (HAVE_32BIT_GPRS
6550               && imm_expr.X_op == O_constant
6551               && imm_expr.X_add_number == -1))
6552         goto do_false;
6553       if (imm_expr.X_op != O_constant)
6554         as_bad (_("Unsupported large constant"));
6555       ++imm_expr.X_add_number;
6556       /* FALLTHROUGH */
6557     case M_BGEU_I:
6558     case M_BGEUL_I:
6559       if (mask == M_BGEUL_I)
6560         likely = 1;
6561       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
6562         goto do_true;
6563       else if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
6564         macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6565                                  &offset_expr, sreg, ZERO);
6566       else
6567         {
6568           used_at = 1;
6569           set_at (sreg, 1);
6570           macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6571                                    &offset_expr, AT, ZERO);
6572         }
6573       break;
6574
6575     case M_BGTL:
6576       likely = 1;
6577     case M_BGT:
6578       if (treg == 0)
6579         macro_build_branch_rs (likely ? M_BGTZL : M_BGTZ, &offset_expr, sreg);
6580       else if (sreg == 0)
6581         macro_build_branch_rs (likely ? M_BLTZL : M_BLTZ, &offset_expr, treg);
6582       else
6583         {
6584           used_at = 1;
6585           macro_build (NULL, "slt", "d,v,t", AT, treg, sreg);
6586           macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6587                                    &offset_expr, AT, ZERO);
6588         }
6589       break;
6590
6591     case M_BGTUL:
6592       likely = 1;
6593     case M_BGTU:
6594       if (treg == 0)
6595         macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6596                                  &offset_expr, sreg, ZERO);
6597       else if (sreg == 0)
6598         goto do_false;
6599       else
6600         {
6601           used_at = 1;
6602           macro_build (NULL, "sltu", "d,v,t", AT, treg, sreg);
6603           macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6604                                    &offset_expr, AT, ZERO);
6605         }
6606       break;
6607
6608     case M_BLEL:
6609       likely = 1;
6610     case M_BLE:
6611       if (treg == 0)
6612         macro_build_branch_rs (likely ? M_BLEZL : M_BLEZ, &offset_expr, sreg);
6613       else if (sreg == 0)
6614         macro_build_branch_rs (likely ? M_BGEZL : M_BGEZ, &offset_expr, treg);
6615       else
6616         {
6617           used_at = 1;
6618           macro_build (NULL, "slt", "d,v,t", AT, treg, sreg);
6619           macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6620                                    &offset_expr, AT, ZERO);
6621         }
6622       break;
6623
6624     case M_BLEL_I:
6625       likely = 1;
6626     case M_BLE_I:
6627       maxnum = 0x7fffffff;
6628       if (HAVE_64BIT_GPRS && sizeof (maxnum) > 4)
6629         {
6630           maxnum <<= 16;
6631           maxnum |= 0xffff;
6632           maxnum <<= 16;
6633           maxnum |= 0xffff;
6634         }
6635       if (imm_expr.X_op == O_constant
6636           && imm_expr.X_add_number >= maxnum
6637           && (HAVE_32BIT_GPRS || sizeof (maxnum) > 4))
6638         goto do_true;
6639       if (imm_expr.X_op != O_constant)
6640         as_bad (_("Unsupported large constant"));
6641       ++imm_expr.X_add_number;
6642       /* FALLTHROUGH */
6643     case M_BLT_I:
6644     case M_BLTL_I:
6645       if (mask == M_BLTL_I)
6646         likely = 1;
6647       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
6648         macro_build_branch_rs (likely ? M_BLTZL : M_BLTZ, &offset_expr, sreg);
6649       else if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
6650         macro_build_branch_rs (likely ? M_BLEZL : M_BLEZ, &offset_expr, sreg);
6651       else
6652         {
6653           used_at = 1;
6654           set_at (sreg, 0);
6655           macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6656                                    &offset_expr, AT, ZERO);
6657         }
6658       break;
6659
6660     case M_BLEUL:
6661       likely = 1;
6662     case M_BLEU:
6663       if (treg == 0)
6664         macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6665                                  &offset_expr, sreg, ZERO);
6666       else if (sreg == 0)
6667         goto do_true;
6668       else
6669         {
6670           used_at = 1;
6671           macro_build (NULL, "sltu", "d,v,t", AT, treg, sreg);
6672           macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6673                                    &offset_expr, AT, ZERO);
6674         }
6675       break;
6676
6677     case M_BLEUL_I:
6678       likely = 1;
6679     case M_BLEU_I:
6680       if (sreg == 0
6681           || (HAVE_32BIT_GPRS
6682               && imm_expr.X_op == O_constant
6683               && imm_expr.X_add_number == -1))
6684         goto do_true;
6685       if (imm_expr.X_op != O_constant)
6686         as_bad (_("Unsupported large constant"));
6687       ++imm_expr.X_add_number;
6688       /* FALLTHROUGH */
6689     case M_BLTU_I:
6690     case M_BLTUL_I:
6691       if (mask == M_BLTUL_I)
6692         likely = 1;
6693       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
6694         goto do_false;
6695       else if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
6696         macro_build_branch_rsrt (likely ? M_BEQL : M_BEQ,
6697                                  &offset_expr, sreg, ZERO);
6698       else
6699         {
6700           used_at = 1;
6701           set_at (sreg, 1);
6702           macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6703                                    &offset_expr, AT, ZERO);
6704         }
6705       break;
6706
6707     case M_BLTL:
6708       likely = 1;
6709     case M_BLT:
6710       if (treg == 0)
6711         macro_build_branch_rs (likely ? M_BLTZL : M_BLTZ, &offset_expr, sreg);
6712       else if (sreg == 0)
6713         macro_build_branch_rs (likely ? M_BGTZL : M_BGTZ, &offset_expr, treg);
6714       else
6715         {
6716           used_at = 1;
6717           macro_build (NULL, "slt", "d,v,t", AT, sreg, treg);
6718           macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6719                                    &offset_expr, AT, ZERO);
6720         }
6721       break;
6722
6723     case M_BLTUL:
6724       likely = 1;
6725     case M_BLTU:
6726       if (treg == 0)
6727         goto do_false;
6728       else if (sreg == 0)
6729         macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6730                                  &offset_expr, ZERO, treg);
6731       else
6732         {
6733           used_at = 1;
6734           macro_build (NULL, "sltu", "d,v,t", AT, sreg, treg);
6735           macro_build_branch_rsrt (likely ? M_BNEL : M_BNE,
6736                                    &offset_expr, AT, ZERO);
6737         }
6738       break;
6739
6740     case M_DEXT:
6741       {
6742         /* Use unsigned arithmetic.  */
6743         addressT pos;
6744         addressT size;
6745
6746         if (imm_expr.X_op != O_constant || imm2_expr.X_op != O_constant)
6747           {
6748             as_bad (_("Unsupported large constant"));
6749             pos = size = 1;
6750           }
6751         else
6752           {
6753             pos = imm_expr.X_add_number;
6754             size = imm2_expr.X_add_number;
6755           }
6756
6757         if (pos > 63)
6758           {
6759             as_bad (_("Improper position (%lu)"), (unsigned long) pos);
6760             pos = 1;
6761           }
6762         if (size == 0 || size > 64 || (pos + size - 1) > 63)
6763           {
6764             as_bad (_("Improper extract size (%lu, position %lu)"),
6765                     (unsigned long) size, (unsigned long) pos);
6766             size = 1;
6767           }
6768
6769         if (size <= 32 && pos < 32)
6770           {
6771             s = "dext";
6772             fmt = "t,r,+A,+C";
6773           }
6774         else if (size <= 32)
6775           {
6776             s = "dextu";
6777             fmt = "t,r,+E,+H";
6778           }
6779         else
6780           {
6781             s = "dextm";
6782             fmt = "t,r,+A,+G";
6783           }
6784         macro_build ((expressionS *) NULL, s, fmt, treg, sreg, (int) pos,
6785                      (int) (size - 1));
6786       }
6787       break;
6788
6789     case M_DINS:
6790       {
6791         /* Use unsigned arithmetic.  */
6792         addressT pos;
6793         addressT size;
6794
6795         if (imm_expr.X_op != O_constant || imm2_expr.X_op != O_constant)
6796           {
6797             as_bad (_("Unsupported large constant"));
6798             pos = size = 1;
6799           }
6800         else
6801           {
6802             pos = imm_expr.X_add_number;
6803             size = imm2_expr.X_add_number;
6804           }
6805
6806         if (pos > 63)
6807           {
6808             as_bad (_("Improper position (%lu)"), (unsigned long) pos);
6809             pos = 1;
6810           }
6811         if (size == 0 || size > 64 || (pos + size - 1) > 63)
6812           {
6813             as_bad (_("Improper insert size (%lu, position %lu)"),
6814                     (unsigned long) size, (unsigned long) pos);
6815             size = 1;
6816           }
6817
6818         if (pos < 32 && (pos + size - 1) < 32)
6819           {
6820             s = "dins";
6821             fmt = "t,r,+A,+B";
6822           }
6823         else if (pos >= 32)
6824           {
6825             s = "dinsu";
6826             fmt = "t,r,+E,+F";
6827           }
6828         else
6829           {
6830             s = "dinsm";
6831             fmt = "t,r,+A,+F";
6832           }
6833         macro_build ((expressionS *) NULL, s, fmt, treg, sreg, (int) pos,
6834                      (int) (pos + size - 1));
6835       }
6836       break;
6837
6838     case M_DDIV_3:
6839       dbl = 1;
6840     case M_DIV_3:
6841       s = "mflo";
6842       goto do_div3;
6843     case M_DREM_3:
6844       dbl = 1;
6845     case M_REM_3:
6846       s = "mfhi";
6847     do_div3:
6848       if (treg == 0)
6849         {
6850           as_warn (_("Divide by zero."));
6851           if (mips_trap)
6852             macro_build (NULL, "teq", TRAP_FMT, ZERO, ZERO, 7);
6853           else
6854             macro_build (NULL, "break", BRK_FMT, 7);
6855           break;
6856         }
6857
6858       start_noreorder ();
6859       if (mips_trap)
6860         {
6861           macro_build (NULL, "teq", TRAP_FMT, treg, ZERO, 7);
6862           macro_build (NULL, dbl ? "ddiv" : "div", "z,s,t", sreg, treg);
6863         }
6864       else
6865         {
6866           if (mips_opts.micromips)
6867             micromips_label_expr (&label_expr);
6868           else
6869             label_expr.X_add_number = 8;
6870           macro_build (&label_expr, "bne", "s,t,p", treg, ZERO);
6871           macro_build (NULL, dbl ? "ddiv" : "div", "z,s,t", sreg, treg);
6872           macro_build (NULL, "break", BRK_FMT, 7);
6873           if (mips_opts.micromips)
6874             micromips_add_label ();
6875         }
6876       expr1.X_add_number = -1;
6877       used_at = 1;
6878       load_register (AT, &expr1, dbl);
6879       if (mips_opts.micromips)
6880         micromips_label_expr (&label_expr);
6881       else
6882         label_expr.X_add_number = mips_trap ? (dbl ? 12 : 8) : (dbl ? 20 : 16);
6883       macro_build (&label_expr, "bne", "s,t,p", treg, AT);
6884       if (dbl)
6885         {
6886           expr1.X_add_number = 1;
6887           load_register (AT, &expr1, dbl);
6888           macro_build (NULL, "dsll32", SHFT_FMT, AT, AT, 31);
6889         }
6890       else
6891         {
6892           expr1.X_add_number = 0x80000000;
6893           macro_build (&expr1, "lui", LUI_FMT, AT, BFD_RELOC_HI16);
6894         }
6895       if (mips_trap)
6896         {
6897           macro_build (NULL, "teq", TRAP_FMT, sreg, AT, 6);
6898           /* We want to close the noreorder block as soon as possible, so
6899              that later insns are available for delay slot filling.  */
6900           end_noreorder ();
6901         }
6902       else
6903         {
6904           if (mips_opts.micromips)
6905             micromips_label_expr (&label_expr);
6906           else
6907             label_expr.X_add_number = 8;
6908           macro_build (&label_expr, "bne", "s,t,p", sreg, AT);
6909           macro_build (NULL, "nop", "");
6910
6911           /* We want to close the noreorder block as soon as possible, so
6912              that later insns are available for delay slot filling.  */
6913           end_noreorder ();
6914
6915           macro_build (NULL, "break", BRK_FMT, 6);
6916         }
6917       if (mips_opts.micromips)
6918         micromips_add_label ();
6919       macro_build (NULL, s, MFHL_FMT, dreg);
6920       break;
6921
6922     case M_DIV_3I:
6923       s = "div";
6924       s2 = "mflo";
6925       goto do_divi;
6926     case M_DIVU_3I:
6927       s = "divu";
6928       s2 = "mflo";
6929       goto do_divi;
6930     case M_REM_3I:
6931       s = "div";
6932       s2 = "mfhi";
6933       goto do_divi;
6934     case M_REMU_3I:
6935       s = "divu";
6936       s2 = "mfhi";
6937       goto do_divi;
6938     case M_DDIV_3I:
6939       dbl = 1;
6940       s = "ddiv";
6941       s2 = "mflo";
6942       goto do_divi;
6943     case M_DDIVU_3I:
6944       dbl = 1;
6945       s = "ddivu";
6946       s2 = "mflo";
6947       goto do_divi;
6948     case M_DREM_3I:
6949       dbl = 1;
6950       s = "ddiv";
6951       s2 = "mfhi";
6952       goto do_divi;
6953     case M_DREMU_3I:
6954       dbl = 1;
6955       s = "ddivu";
6956       s2 = "mfhi";
6957     do_divi:
6958       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
6959         {
6960           as_warn (_("Divide by zero."));
6961           if (mips_trap)
6962             macro_build (NULL, "teq", TRAP_FMT, ZERO, ZERO, 7);
6963           else
6964             macro_build (NULL, "break", BRK_FMT, 7);
6965           break;
6966         }
6967       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
6968         {
6969           if (strcmp (s2, "mflo") == 0)
6970             move_register (dreg, sreg);
6971           else
6972             move_register (dreg, ZERO);
6973           break;
6974         }
6975       if (imm_expr.X_op == O_constant
6976           && imm_expr.X_add_number == -1
6977           && s[strlen (s) - 1] != 'u')
6978         {
6979           if (strcmp (s2, "mflo") == 0)
6980             {
6981               macro_build (NULL, dbl ? "dneg" : "neg", "d,w", dreg, sreg);
6982             }
6983           else
6984             move_register (dreg, ZERO);
6985           break;
6986         }
6987
6988       used_at = 1;
6989       load_register (AT, &imm_expr, dbl);
6990       macro_build (NULL, s, "z,s,t", sreg, AT);
6991       macro_build (NULL, s2, MFHL_FMT, dreg);
6992       break;
6993
6994     case M_DIVU_3:
6995       s = "divu";
6996       s2 = "mflo";
6997       goto do_divu3;
6998     case M_REMU_3:
6999       s = "divu";
7000       s2 = "mfhi";
7001       goto do_divu3;
7002     case M_DDIVU_3:
7003       s = "ddivu";
7004       s2 = "mflo";
7005       goto do_divu3;
7006     case M_DREMU_3:
7007       s = "ddivu";
7008       s2 = "mfhi";
7009     do_divu3:
7010       start_noreorder ();
7011       if (mips_trap)
7012         {
7013           macro_build (NULL, "teq", TRAP_FMT, treg, ZERO, 7);
7014           macro_build (NULL, s, "z,s,t", sreg, treg);
7015           /* We want to close the noreorder block as soon as possible, so
7016              that later insns are available for delay slot filling.  */
7017           end_noreorder ();
7018         }
7019       else
7020         {
7021           if (mips_opts.micromips)
7022             micromips_label_expr (&label_expr);
7023           else
7024             label_expr.X_add_number = 8;
7025           macro_build (&label_expr, "bne", "s,t,p", treg, ZERO);
7026           macro_build (NULL, s, "z,s,t", sreg, treg);
7027
7028           /* We want to close the noreorder block as soon as possible, so
7029              that later insns are available for delay slot filling.  */
7030           end_noreorder ();
7031           macro_build (NULL, "break", BRK_FMT, 7);
7032           if (mips_opts.micromips)
7033             micromips_add_label ();
7034         }
7035       macro_build (NULL, s2, MFHL_FMT, dreg);
7036       break;
7037
7038     case M_DLCA_AB:
7039       dbl = 1;
7040     case M_LCA_AB:
7041       call = 1;
7042       goto do_la;
7043     case M_DLA_AB:
7044       dbl = 1;
7045     case M_LA_AB:
7046     do_la:
7047       /* Load the address of a symbol into a register.  If breg is not
7048          zero, we then add a base register to it.  */
7049
7050       if (dbl && HAVE_32BIT_GPRS)
7051         as_warn (_("dla used to load 32-bit register"));
7052
7053       if (!dbl && HAVE_64BIT_OBJECTS)
7054         as_warn (_("la used to load 64-bit address"));
7055
7056       if (offset_expr.X_op == O_constant
7057           && offset_expr.X_add_number >= -0x8000
7058           && offset_expr.X_add_number < 0x8000)
7059         {
7060           macro_build (&offset_expr, ADDRESS_ADDI_INSN,
7061                        "t,r,j", treg, sreg, BFD_RELOC_LO16);
7062           break;
7063         }
7064
7065       if (mips_opts.at && (treg == breg))
7066         {
7067           tempreg = AT;
7068           used_at = 1;
7069         }
7070       else
7071         {
7072           tempreg = treg;
7073         }
7074
7075       if (offset_expr.X_op != O_symbol
7076           && offset_expr.X_op != O_constant)
7077         {
7078           as_bad (_("Expression too complex"));
7079           offset_expr.X_op = O_constant;
7080         }
7081
7082       if (offset_expr.X_op == O_constant)
7083         load_register (tempreg, &offset_expr, HAVE_64BIT_ADDRESSES);
7084       else if (mips_pic == NO_PIC)
7085         {
7086           /* If this is a reference to a GP relative symbol, we want
7087                addiu    $tempreg,$gp,<sym>      (BFD_RELOC_GPREL16)
7088              Otherwise we want
7089                lui      $tempreg,<sym>          (BFD_RELOC_HI16_S)
7090                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
7091              If we have a constant, we need two instructions anyhow,
7092              so we may as well always use the latter form.
7093
7094              With 64bit address space and a usable $at we want
7095                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
7096                lui      $at,<sym>               (BFD_RELOC_HI16_S)
7097                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
7098                daddiu   $at,<sym>               (BFD_RELOC_LO16)
7099                dsll32   $tempreg,0
7100                daddu    $tempreg,$tempreg,$at
7101
7102              If $at is already in use, we use a path which is suboptimal
7103              on superscalar processors.
7104                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
7105                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
7106                dsll     $tempreg,16
7107                daddiu   $tempreg,<sym>          (BFD_RELOC_HI16_S)
7108                dsll     $tempreg,16
7109                daddiu   $tempreg,<sym>          (BFD_RELOC_LO16)
7110
7111              For GP relative symbols in 64bit address space we can use
7112              the same sequence as in 32bit address space.  */
7113           if (HAVE_64BIT_SYMBOLS)
7114             {
7115               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
7116                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
7117                 {
7118                   relax_start (offset_expr.X_add_symbol);
7119                   macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7120                                tempreg, mips_gp_register, BFD_RELOC_GPREL16);
7121                   relax_switch ();
7122                 }
7123
7124               if (used_at == 0 && mips_opts.at)
7125                 {
7126                   macro_build (&offset_expr, "lui", LUI_FMT,
7127                                tempreg, BFD_RELOC_MIPS_HIGHEST);
7128                   macro_build (&offset_expr, "lui", LUI_FMT,
7129                                AT, BFD_RELOC_HI16_S);
7130                   macro_build (&offset_expr, "daddiu", "t,r,j",
7131                                tempreg, tempreg, BFD_RELOC_MIPS_HIGHER);
7132                   macro_build (&offset_expr, "daddiu", "t,r,j",
7133                                AT, AT, BFD_RELOC_LO16);
7134                   macro_build (NULL, "dsll32", SHFT_FMT, tempreg, tempreg, 0);
7135                   macro_build (NULL, "daddu", "d,v,t", tempreg, tempreg, AT);
7136                   used_at = 1;
7137                 }
7138               else
7139                 {
7140                   macro_build (&offset_expr, "lui", LUI_FMT,
7141                                tempreg, BFD_RELOC_MIPS_HIGHEST);
7142                   macro_build (&offset_expr, "daddiu", "t,r,j",
7143                                tempreg, tempreg, BFD_RELOC_MIPS_HIGHER);
7144                   macro_build (NULL, "dsll", SHFT_FMT, tempreg, tempreg, 16);
7145                   macro_build (&offset_expr, "daddiu", "t,r,j",
7146                                tempreg, tempreg, BFD_RELOC_HI16_S);
7147                   macro_build (NULL, "dsll", SHFT_FMT, tempreg, tempreg, 16);
7148                   macro_build (&offset_expr, "daddiu", "t,r,j",
7149                                tempreg, tempreg, BFD_RELOC_LO16);
7150                 }
7151
7152               if (mips_relax.sequence)
7153                 relax_end ();
7154             }
7155           else
7156             {
7157               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
7158                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
7159                 {
7160                   relax_start (offset_expr.X_add_symbol);
7161                   macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7162                                tempreg, mips_gp_register, BFD_RELOC_GPREL16);
7163                   relax_switch ();
7164                 }
7165               if (!IS_SEXT_32BIT_NUM (offset_expr.X_add_number))
7166                 as_bad (_("Offset too large"));
7167               macro_build_lui (&offset_expr, tempreg);
7168               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7169                            tempreg, tempreg, BFD_RELOC_LO16);
7170               if (mips_relax.sequence)
7171                 relax_end ();
7172             }
7173         }
7174       else if (!mips_big_got && !HAVE_NEWABI)
7175         {
7176           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT16;
7177
7178           /* If this is a reference to an external symbol, and there
7179              is no constant, we want
7180                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
7181              or for lca or if tempreg is PIC_CALL_REG
7182                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_CALL16)
7183              For a local symbol, we want
7184                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
7185                nop
7186                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
7187
7188              If we have a small constant, and this is a reference to
7189              an external symbol, we want
7190                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
7191                nop
7192                addiu    $tempreg,$tempreg,<constant>
7193              For a local symbol, we want the same instruction
7194              sequence, but we output a BFD_RELOC_LO16 reloc on the
7195              addiu instruction.
7196
7197              If we have a large constant, and this is a reference to
7198              an external symbol, we want
7199                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
7200                lui      $at,<hiconstant>
7201                addiu    $at,$at,<loconstant>
7202                addu     $tempreg,$tempreg,$at
7203              For a local symbol, we want the same instruction
7204              sequence, but we output a BFD_RELOC_LO16 reloc on the
7205              addiu instruction.
7206            */
7207
7208           if (offset_expr.X_add_number == 0)
7209             {
7210               if (mips_pic == SVR4_PIC
7211                   && breg == 0
7212                   && (call || tempreg == PIC_CALL_REG))
7213                 lw_reloc_type = (int) BFD_RELOC_MIPS_CALL16;
7214
7215               relax_start (offset_expr.X_add_symbol);
7216               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7217                            lw_reloc_type, mips_gp_register);
7218               if (breg != 0)
7219                 {
7220                   /* We're going to put in an addu instruction using
7221                      tempreg, so we may as well insert the nop right
7222                      now.  */
7223                   load_delay_nop ();
7224                 }
7225               relax_switch ();
7226               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7227                            tempreg, BFD_RELOC_MIPS_GOT16, mips_gp_register);
7228               load_delay_nop ();
7229               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7230                            tempreg, tempreg, BFD_RELOC_LO16);
7231               relax_end ();
7232               /* FIXME: If breg == 0, and the next instruction uses
7233                  $tempreg, then if this variant case is used an extra
7234                  nop will be generated.  */
7235             }
7236           else if (offset_expr.X_add_number >= -0x8000
7237                    && offset_expr.X_add_number < 0x8000)
7238             {
7239               load_got_offset (tempreg, &offset_expr);
7240               load_delay_nop ();
7241               add_got_offset (tempreg, &offset_expr);
7242             }
7243           else
7244             {
7245               expr1.X_add_number = offset_expr.X_add_number;
7246               offset_expr.X_add_number =
7247                 ((offset_expr.X_add_number + 0x8000) & 0xffff) - 0x8000;
7248               load_got_offset (tempreg, &offset_expr);
7249               offset_expr.X_add_number = expr1.X_add_number;
7250               /* If we are going to add in a base register, and the
7251                  target register and the base register are the same,
7252                  then we are using AT as a temporary register.  Since
7253                  we want to load the constant into AT, we add our
7254                  current AT (from the global offset table) and the
7255                  register into the register now, and pretend we were
7256                  not using a base register.  */
7257               if (breg == treg)
7258                 {
7259                   load_delay_nop ();
7260                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7261                                treg, AT, breg);
7262                   breg = 0;
7263                   tempreg = treg;
7264                 }
7265               add_got_offset_hilo (tempreg, &offset_expr, AT);
7266               used_at = 1;
7267             }
7268         }
7269       else if (!mips_big_got && HAVE_NEWABI)
7270         {
7271           int add_breg_early = 0;
7272
7273           /* If this is a reference to an external, and there is no
7274              constant, or local symbol (*), with or without a
7275              constant, we want
7276                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
7277              or for lca or if tempreg is PIC_CALL_REG
7278                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_CALL16)
7279
7280              If we have a small constant, and this is a reference to
7281              an external symbol, we want
7282                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
7283                addiu    $tempreg,$tempreg,<constant>
7284
7285              If we have a large constant, and this is a reference to
7286              an external symbol, we want
7287                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
7288                lui      $at,<hiconstant>
7289                addiu    $at,$at,<loconstant>
7290                addu     $tempreg,$tempreg,$at
7291
7292              (*) Other assemblers seem to prefer GOT_PAGE/GOT_OFST for
7293              local symbols, even though it introduces an additional
7294              instruction.  */
7295
7296           if (offset_expr.X_add_number)
7297             {
7298               expr1.X_add_number = offset_expr.X_add_number;
7299               offset_expr.X_add_number = 0;
7300
7301               relax_start (offset_expr.X_add_symbol);
7302               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7303                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
7304
7305               if (expr1.X_add_number >= -0x8000
7306                   && expr1.X_add_number < 0x8000)
7307                 {
7308                   macro_build (&expr1, ADDRESS_ADDI_INSN, "t,r,j",
7309                                tempreg, tempreg, BFD_RELOC_LO16);
7310                 }
7311               else if (IS_SEXT_32BIT_NUM (expr1.X_add_number + 0x8000))
7312                 {
7313                   /* If we are going to add in a base register, and the
7314                      target register and the base register are the same,
7315                      then we are using AT as a temporary register.  Since
7316                      we want to load the constant into AT, we add our
7317                      current AT (from the global offset table) and the
7318                      register into the register now, and pretend we were
7319                      not using a base register.  */
7320                   if (breg != treg)
7321                     dreg = tempreg;
7322                   else
7323                     {
7324                       gas_assert (tempreg == AT);
7325                       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7326                                    treg, AT, breg);
7327                       dreg = treg;
7328                       add_breg_early = 1;
7329                     }
7330
7331                   load_register (AT, &expr1, HAVE_64BIT_ADDRESSES);
7332                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7333                                dreg, dreg, AT);
7334
7335                   used_at = 1;
7336                 }
7337               else
7338                 as_bad (_("PIC code offset overflow (max 32 signed bits)"));
7339
7340               relax_switch ();
7341               offset_expr.X_add_number = expr1.X_add_number;
7342
7343               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7344                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
7345               if (add_breg_early)
7346                 {
7347                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7348                                treg, tempreg, breg);
7349                   breg = 0;
7350                   tempreg = treg;
7351                 }
7352               relax_end ();
7353             }
7354           else if (breg == 0 && (call || tempreg == PIC_CALL_REG))
7355             {
7356               relax_start (offset_expr.X_add_symbol);
7357               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7358                            BFD_RELOC_MIPS_CALL16, mips_gp_register);
7359               relax_switch ();
7360               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7361                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
7362               relax_end ();
7363             }
7364           else
7365             {
7366               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7367                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
7368             }
7369         }
7370       else if (mips_big_got && !HAVE_NEWABI)
7371         {
7372           int gpdelay;
7373           int lui_reloc_type = (int) BFD_RELOC_MIPS_GOT_HI16;
7374           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT_LO16;
7375           int local_reloc_type = (int) BFD_RELOC_MIPS_GOT16;
7376
7377           /* This is the large GOT case.  If this is a reference to an
7378              external symbol, and there is no constant, we want
7379                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
7380                addu     $tempreg,$tempreg,$gp
7381                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7382              or for lca or if tempreg is PIC_CALL_REG
7383                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_CALL_HI16)
7384                addu     $tempreg,$tempreg,$gp
7385                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_CALL_LO16)
7386              For a local symbol, we want
7387                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
7388                nop
7389                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
7390
7391              If we have a small constant, and this is a reference to
7392              an external symbol, we want
7393                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
7394                addu     $tempreg,$tempreg,$gp
7395                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7396                nop
7397                addiu    $tempreg,$tempreg,<constant>
7398              For a local symbol, we want
7399                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
7400                nop
7401                addiu    $tempreg,$tempreg,<constant> (BFD_RELOC_LO16)
7402
7403              If we have a large constant, and this is a reference to
7404              an external symbol, we want
7405                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
7406                addu     $tempreg,$tempreg,$gp
7407                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7408                lui      $at,<hiconstant>
7409                addiu    $at,$at,<loconstant>
7410                addu     $tempreg,$tempreg,$at
7411              For a local symbol, we want
7412                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
7413                lui      $at,<hiconstant>
7414                addiu    $at,$at,<loconstant>    (BFD_RELOC_LO16)
7415                addu     $tempreg,$tempreg,$at
7416           */
7417
7418           expr1.X_add_number = offset_expr.X_add_number;
7419           offset_expr.X_add_number = 0;
7420           relax_start (offset_expr.X_add_symbol);
7421           gpdelay = reg_needs_delay (mips_gp_register);
7422           if (expr1.X_add_number == 0 && breg == 0
7423               && (call || tempreg == PIC_CALL_REG))
7424             {
7425               lui_reloc_type = (int) BFD_RELOC_MIPS_CALL_HI16;
7426               lw_reloc_type = (int) BFD_RELOC_MIPS_CALL_LO16;
7427             }
7428           macro_build (&offset_expr, "lui", LUI_FMT, tempreg, lui_reloc_type);
7429           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7430                        tempreg, tempreg, mips_gp_register);
7431           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7432                        tempreg, lw_reloc_type, tempreg);
7433           if (expr1.X_add_number == 0)
7434             {
7435               if (breg != 0)
7436                 {
7437                   /* We're going to put in an addu instruction using
7438                      tempreg, so we may as well insert the nop right
7439                      now.  */
7440                   load_delay_nop ();
7441                 }
7442             }
7443           else if (expr1.X_add_number >= -0x8000
7444                    && expr1.X_add_number < 0x8000)
7445             {
7446               load_delay_nop ();
7447               macro_build (&expr1, ADDRESS_ADDI_INSN, "t,r,j",
7448                            tempreg, tempreg, BFD_RELOC_LO16);
7449             }
7450           else
7451             {
7452               /* If we are going to add in a base register, and the
7453                  target register and the base register are the same,
7454                  then we are using AT as a temporary register.  Since
7455                  we want to load the constant into AT, we add our
7456                  current AT (from the global offset table) and the
7457                  register into the register now, and pretend we were
7458                  not using a base register.  */
7459               if (breg != treg)
7460                 dreg = tempreg;
7461               else
7462                 {
7463                   gas_assert (tempreg == AT);
7464                   load_delay_nop ();
7465                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7466                                treg, AT, breg);
7467                   dreg = treg;
7468                 }
7469
7470               load_register (AT, &expr1, HAVE_64BIT_ADDRESSES);
7471               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", dreg, dreg, AT);
7472
7473               used_at = 1;
7474             }
7475           offset_expr.X_add_number =
7476             ((expr1.X_add_number + 0x8000) & 0xffff) - 0x8000;
7477           relax_switch ();
7478
7479           if (gpdelay)
7480             {
7481               /* This is needed because this instruction uses $gp, but
7482                  the first instruction on the main stream does not.  */
7483               macro_build (NULL, "nop", "");
7484             }
7485
7486           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7487                        local_reloc_type, mips_gp_register);
7488           if (expr1.X_add_number >= -0x8000
7489               && expr1.X_add_number < 0x8000)
7490             {
7491               load_delay_nop ();
7492               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7493                            tempreg, tempreg, BFD_RELOC_LO16);
7494               /* FIXME: If add_number is 0, and there was no base
7495                  register, the external symbol case ended with a load,
7496                  so if the symbol turns out to not be external, and
7497                  the next instruction uses tempreg, an unnecessary nop
7498                  will be inserted.  */
7499             }
7500           else
7501             {
7502               if (breg == treg)
7503                 {
7504                   /* We must add in the base register now, as in the
7505                      external symbol case.  */
7506                   gas_assert (tempreg == AT);
7507                   load_delay_nop ();
7508                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7509                                treg, AT, breg);
7510                   tempreg = treg;
7511                   /* We set breg to 0 because we have arranged to add
7512                      it in in both cases.  */
7513                   breg = 0;
7514                 }
7515
7516               macro_build_lui (&expr1, AT);
7517               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7518                            AT, AT, BFD_RELOC_LO16);
7519               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7520                            tempreg, tempreg, AT);
7521               used_at = 1;
7522             }
7523           relax_end ();
7524         }
7525       else if (mips_big_got && HAVE_NEWABI)
7526         {
7527           int lui_reloc_type = (int) BFD_RELOC_MIPS_GOT_HI16;
7528           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT_LO16;
7529           int add_breg_early = 0;
7530
7531           /* This is the large GOT case.  If this is a reference to an
7532              external symbol, and there is no constant, we want
7533                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
7534                add      $tempreg,$tempreg,$gp
7535                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7536              or for lca or if tempreg is PIC_CALL_REG
7537                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_CALL_HI16)
7538                add      $tempreg,$tempreg,$gp
7539                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_CALL_LO16)
7540
7541              If we have a small constant, and this is a reference to
7542              an external symbol, we want
7543                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
7544                add      $tempreg,$tempreg,$gp
7545                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7546                addi     $tempreg,$tempreg,<constant>
7547
7548              If we have a large constant, and this is a reference to
7549              an external symbol, we want
7550                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
7551                addu     $tempreg,$tempreg,$gp
7552                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7553                lui      $at,<hiconstant>
7554                addi     $at,$at,<loconstant>
7555                add      $tempreg,$tempreg,$at
7556
7557              If we have NewABI, and we know it's a local symbol, we want
7558                lw       $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT_PAGE)
7559                addiu    $reg,$reg,<sym>         (BFD_RELOC_MIPS_GOT_OFST)
7560              otherwise we have to resort to GOT_HI16/GOT_LO16.  */
7561
7562           relax_start (offset_expr.X_add_symbol);
7563
7564           expr1.X_add_number = offset_expr.X_add_number;
7565           offset_expr.X_add_number = 0;
7566
7567           if (expr1.X_add_number == 0 && breg == 0
7568               && (call || tempreg == PIC_CALL_REG))
7569             {
7570               lui_reloc_type = (int) BFD_RELOC_MIPS_CALL_HI16;
7571               lw_reloc_type = (int) BFD_RELOC_MIPS_CALL_LO16;
7572             }
7573           macro_build (&offset_expr, "lui", LUI_FMT, tempreg, lui_reloc_type);
7574           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7575                        tempreg, tempreg, mips_gp_register);
7576           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7577                        tempreg, lw_reloc_type, tempreg);
7578
7579           if (expr1.X_add_number == 0)
7580             ;
7581           else if (expr1.X_add_number >= -0x8000
7582                    && expr1.X_add_number < 0x8000)
7583             {
7584               macro_build (&expr1, ADDRESS_ADDI_INSN, "t,r,j",
7585                            tempreg, tempreg, BFD_RELOC_LO16);
7586             }
7587           else if (IS_SEXT_32BIT_NUM (expr1.X_add_number + 0x8000))
7588             {
7589               /* If we are going to add in a base register, and the
7590                  target register and the base register are the same,
7591                  then we are using AT as a temporary register.  Since
7592                  we want to load the constant into AT, we add our
7593                  current AT (from the global offset table) and the
7594                  register into the register now, and pretend we were
7595                  not using a base register.  */
7596               if (breg != treg)
7597                 dreg = tempreg;
7598               else
7599                 {
7600                   gas_assert (tempreg == AT);
7601                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7602                                treg, AT, breg);
7603                   dreg = treg;
7604                   add_breg_early = 1;
7605                 }
7606
7607               load_register (AT, &expr1, HAVE_64BIT_ADDRESSES);
7608               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", dreg, dreg, AT);
7609
7610               used_at = 1;
7611             }
7612           else
7613             as_bad (_("PIC code offset overflow (max 32 signed bits)"));
7614
7615           relax_switch ();
7616           offset_expr.X_add_number = expr1.X_add_number;
7617           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
7618                        BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
7619           macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j", tempreg,
7620                        tempreg, BFD_RELOC_MIPS_GOT_OFST);
7621           if (add_breg_early)
7622             {
7623               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7624                            treg, tempreg, breg);
7625               breg = 0;
7626               tempreg = treg;
7627             }
7628           relax_end ();
7629         }
7630       else
7631         abort ();
7632
7633       if (breg != 0)
7634         macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", treg, tempreg, breg);
7635       break;
7636
7637     case M_MSGSND:
7638       gas_assert (!mips_opts.micromips);
7639       {
7640         unsigned long temp = (treg << 16) | (0x01);
7641         macro_build (NULL, "c2", "C", temp);
7642       }
7643       break;
7644
7645     case M_MSGLD:
7646       gas_assert (!mips_opts.micromips);
7647       {
7648         unsigned long temp = (0x02);
7649         macro_build (NULL, "c2", "C", temp);
7650       }
7651       break;
7652
7653     case M_MSGLD_T:
7654       gas_assert (!mips_opts.micromips);
7655       {
7656         unsigned long temp = (treg << 16) | (0x02);
7657         macro_build (NULL, "c2", "C", temp);
7658       }
7659       break;
7660
7661     case M_MSGWAIT:
7662       gas_assert (!mips_opts.micromips);
7663       macro_build (NULL, "c2", "C", 3);
7664       break;
7665
7666     case M_MSGWAIT_T:
7667       gas_assert (!mips_opts.micromips);
7668       {
7669         unsigned long temp = (treg << 16) | 0x03;
7670         macro_build (NULL, "c2", "C", temp);
7671       }
7672       break;
7673
7674     case M_J_A:
7675       /* The j instruction may not be used in PIC code, since it
7676          requires an absolute address.  We convert it to a b
7677          instruction.  */
7678       if (mips_pic == NO_PIC)
7679         macro_build (&offset_expr, "j", "a");
7680       else
7681         macro_build (&offset_expr, "b", "p");
7682       break;
7683
7684       /* The jal instructions must be handled as macros because when
7685          generating PIC code they expand to multi-instruction
7686          sequences.  Normally they are simple instructions.  */
7687     case M_JALS_1:
7688       dreg = RA;
7689       /* Fall through.  */
7690     case M_JALS_2:
7691       gas_assert (mips_opts.micromips);
7692       jals = 1;
7693       goto jal;
7694     case M_JAL_1:
7695       dreg = RA;
7696       /* Fall through.  */
7697     case M_JAL_2:
7698     jal:
7699       if (mips_pic == NO_PIC)
7700         {
7701           s = jals ? "jalrs" : "jalr";
7702           if (mips_opts.micromips && dreg == RA)
7703             macro_build (NULL, s, "mj", sreg);
7704           else
7705             macro_build (NULL, s, JALR_FMT, dreg, sreg);
7706         }
7707       else
7708         {
7709           int cprestore = (mips_pic == SVR4_PIC && !HAVE_NEWABI
7710                            && mips_cprestore_offset >= 0);
7711
7712           if (sreg != PIC_CALL_REG)
7713             as_warn (_("MIPS PIC call to register other than $25"));
7714
7715           s = (mips_opts.micromips && (!mips_opts.noreorder || cprestore)
7716                ? "jalrs" : "jalr");
7717           if (mips_opts.micromips && dreg == RA)
7718             macro_build (NULL, s, "mj", sreg);
7719           else
7720             macro_build (NULL, s, JALR_FMT, dreg, sreg);
7721           if (mips_pic == SVR4_PIC && !HAVE_NEWABI)
7722             {
7723               if (mips_cprestore_offset < 0)
7724                 as_warn (_("No .cprestore pseudo-op used in PIC code"));
7725               else
7726                 {
7727                   if (!mips_frame_reg_valid)
7728                     {
7729                       as_warn (_("No .frame pseudo-op used in PIC code"));
7730                       /* Quiet this warning.  */
7731                       mips_frame_reg_valid = 1;
7732                     }
7733                   if (!mips_cprestore_valid)
7734                     {
7735                       as_warn (_("No .cprestore pseudo-op used in PIC code"));
7736                       /* Quiet this warning.  */
7737                       mips_cprestore_valid = 1;
7738                     }
7739                   if (mips_opts.noreorder)
7740                     macro_build (NULL, "nop", "");
7741                   expr1.X_add_number = mips_cprestore_offset;
7742                   macro_build_ldst_constoffset (&expr1, ADDRESS_LOAD_INSN,
7743                                                 mips_gp_register,
7744                                                 mips_frame_reg,
7745                                                 HAVE_64BIT_ADDRESSES);
7746                 }
7747             }
7748         }
7749
7750       break;
7751
7752     case M_JALS_A:
7753       gas_assert (mips_opts.micromips);
7754       jals = 1;
7755       /* Fall through.  */
7756     case M_JAL_A:
7757       if (mips_pic == NO_PIC)
7758         macro_build (&offset_expr, jals ? "jals" : "jal", "a");
7759       else if (mips_pic == SVR4_PIC)
7760         {
7761           /* If this is a reference to an external symbol, and we are
7762              using a small GOT, we want
7763                lw       $25,<sym>($gp)          (BFD_RELOC_MIPS_CALL16)
7764                nop
7765                jalr     $ra,$25
7766                nop
7767                lw       $gp,cprestore($sp)
7768              The cprestore value is set using the .cprestore
7769              pseudo-op.  If we are using a big GOT, we want
7770                lui      $25,<sym>               (BFD_RELOC_MIPS_CALL_HI16)
7771                addu     $25,$25,$gp
7772                lw       $25,<sym>($25)          (BFD_RELOC_MIPS_CALL_LO16)
7773                nop
7774                jalr     $ra,$25
7775                nop
7776                lw       $gp,cprestore($sp)
7777              If the symbol is not external, we want
7778                lw       $25,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
7779                nop
7780                addiu    $25,$25,<sym>           (BFD_RELOC_LO16)
7781                jalr     $ra,$25
7782                nop
7783                lw $gp,cprestore($sp)
7784
7785              For NewABI, we use the same CALL16 or CALL_HI16/CALL_LO16
7786              sequences above, minus nops, unless the symbol is local,
7787              which enables us to use GOT_PAGE/GOT_OFST (big got) or
7788              GOT_DISP.  */
7789           if (HAVE_NEWABI)
7790             {
7791               if (!mips_big_got)
7792                 {
7793                   relax_start (offset_expr.X_add_symbol);
7794                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7795                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL16,
7796                                mips_gp_register);
7797                   relax_switch ();
7798                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7799                                PIC_CALL_REG, BFD_RELOC_MIPS_GOT_DISP,
7800                                mips_gp_register);
7801                   relax_end ();
7802                 }
7803               else
7804                 {
7805                   relax_start (offset_expr.X_add_symbol);
7806                   macro_build (&offset_expr, "lui", LUI_FMT, PIC_CALL_REG,
7807                                BFD_RELOC_MIPS_CALL_HI16);
7808                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", PIC_CALL_REG,
7809                                PIC_CALL_REG, mips_gp_register);
7810                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7811                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL_LO16,
7812                                PIC_CALL_REG);
7813                   relax_switch ();
7814                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7815                                PIC_CALL_REG, BFD_RELOC_MIPS_GOT_PAGE,
7816                                mips_gp_register);
7817                   macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7818                                PIC_CALL_REG, PIC_CALL_REG,
7819                                BFD_RELOC_MIPS_GOT_OFST);
7820                   relax_end ();
7821                 }
7822
7823               macro_build_jalr (&offset_expr, 0);
7824             }
7825           else
7826             {
7827               relax_start (offset_expr.X_add_symbol);
7828               if (!mips_big_got)
7829                 {
7830                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7831                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL16,
7832                                mips_gp_register);
7833                   load_delay_nop ();
7834                   relax_switch ();
7835                 }
7836               else
7837                 {
7838                   int gpdelay;
7839
7840                   gpdelay = reg_needs_delay (mips_gp_register);
7841                   macro_build (&offset_expr, "lui", LUI_FMT, PIC_CALL_REG,
7842                                BFD_RELOC_MIPS_CALL_HI16);
7843                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", PIC_CALL_REG,
7844                                PIC_CALL_REG, mips_gp_register);
7845                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7846                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL_LO16,
7847                                PIC_CALL_REG);
7848                   load_delay_nop ();
7849                   relax_switch ();
7850                   if (gpdelay)
7851                     macro_build (NULL, "nop", "");
7852                 }
7853               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7854                            PIC_CALL_REG, BFD_RELOC_MIPS_GOT16,
7855                            mips_gp_register);
7856               load_delay_nop ();
7857               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
7858                            PIC_CALL_REG, PIC_CALL_REG, BFD_RELOC_LO16);
7859               relax_end ();
7860               macro_build_jalr (&offset_expr, mips_cprestore_offset >= 0);
7861
7862               if (mips_cprestore_offset < 0)
7863                 as_warn (_("No .cprestore pseudo-op used in PIC code"));
7864               else
7865                 {
7866                   if (!mips_frame_reg_valid)
7867                     {
7868                       as_warn (_("No .frame pseudo-op used in PIC code"));
7869                       /* Quiet this warning.  */
7870                       mips_frame_reg_valid = 1;
7871                     }
7872                   if (!mips_cprestore_valid)
7873                     {
7874                       as_warn (_("No .cprestore pseudo-op used in PIC code"));
7875                       /* Quiet this warning.  */
7876                       mips_cprestore_valid = 1;
7877                     }
7878                   if (mips_opts.noreorder)
7879                     macro_build (NULL, "nop", "");
7880                   expr1.X_add_number = mips_cprestore_offset;
7881                   macro_build_ldst_constoffset (&expr1, ADDRESS_LOAD_INSN,
7882                                                 mips_gp_register,
7883                                                 mips_frame_reg,
7884                                                 HAVE_64BIT_ADDRESSES);
7885                 }
7886             }
7887         }
7888       else if (mips_pic == VXWORKS_PIC)
7889         as_bad (_("Non-PIC jump used in PIC library"));
7890       else
7891         abort ();
7892
7893       break;
7894
7895     case M_ACLR_AB:
7896       ab = 1;
7897     case M_ACLR_OB:
7898       s = "aclr";
7899       treg = EXTRACT_OPERAND (mips_opts.micromips, 3BITPOS, *ip);
7900       fmt = "\\,~(b)";
7901       off12 = 1;
7902       goto ld_st;
7903     case M_ASET_AB:
7904       ab = 1;
7905     case M_ASET_OB:
7906       s = "aset";
7907       treg = EXTRACT_OPERAND (mips_opts.micromips, 3BITPOS, *ip);
7908       fmt = "\\,~(b)";
7909       off12 = 1;
7910       goto ld_st;
7911     case M_LB_AB:
7912       ab = 1;
7913       s = "lb";
7914       fmt = "t,o(b)";
7915       goto ld;
7916     case M_LBU_AB:
7917       ab = 1;
7918       s = "lbu";
7919       fmt = "t,o(b)";
7920       goto ld;
7921     case M_LH_AB:
7922       ab = 1;
7923       s = "lh";
7924       fmt = "t,o(b)";
7925       goto ld;
7926     case M_LHU_AB:
7927       ab = 1;
7928       s = "lhu";
7929       fmt = "t,o(b)";
7930       goto ld;
7931     case M_LW_AB:
7932       ab = 1;
7933       s = "lw";
7934       fmt = "t,o(b)";
7935       goto ld;
7936     case M_LWC0_AB:
7937       ab = 1;
7938       gas_assert (!mips_opts.micromips);
7939       s = "lwc0";
7940       fmt = "E,o(b)";
7941       /* Itbl support may require additional care here.  */
7942       coproc = 1;
7943       goto ld_st;
7944     case M_LWC1_AB:
7945       ab = 1;
7946       s = "lwc1";
7947       fmt = "T,o(b)";
7948       /* Itbl support may require additional care here.  */
7949       coproc = 1;
7950       goto ld_st;
7951     case M_LWC2_AB:
7952       ab = 1;
7953     case M_LWC2_OB:
7954       s = "lwc2";
7955       fmt = COP12_FMT;
7956       off12 = mips_opts.micromips;
7957       /* Itbl support may require additional care here.  */
7958       coproc = 1;
7959       goto ld_st;
7960     case M_LWC3_AB:
7961       ab = 1;
7962       gas_assert (!mips_opts.micromips);
7963       s = "lwc3";
7964       fmt = "E,o(b)";
7965       /* Itbl support may require additional care here.  */
7966       coproc = 1;
7967       goto ld_st;
7968     case M_LWL_AB:
7969       ab = 1;
7970     case M_LWL_OB:
7971       s = "lwl";
7972       fmt = MEM12_FMT;
7973       off12 = mips_opts.micromips;
7974       goto ld_st;
7975     case M_LWR_AB:
7976       ab = 1;
7977     case M_LWR_OB:
7978       s = "lwr";
7979       fmt = MEM12_FMT;
7980       off12 = mips_opts.micromips;
7981       goto ld_st;
7982     case M_LDC1_AB:
7983       ab = 1;
7984       s = "ldc1";
7985       fmt = "T,o(b)";
7986       /* Itbl support may require additional care here.  */
7987       coproc = 1;
7988       goto ld_st;
7989     case M_LDC2_AB:
7990       ab = 1;
7991     case M_LDC2_OB:
7992       s = "ldc2";
7993       fmt = COP12_FMT;
7994       off12 = mips_opts.micromips;
7995       /* Itbl support may require additional care here.  */
7996       coproc = 1;
7997       goto ld_st;
7998     case M_LDC3_AB:
7999       ab = 1;
8000       s = "ldc3";
8001       fmt = "E,o(b)";
8002       /* Itbl support may require additional care here.  */
8003       coproc = 1;
8004       goto ld_st;
8005     case M_LDL_AB:
8006       ab = 1;
8007     case M_LDL_OB:
8008       s = "ldl";
8009       fmt = MEM12_FMT;
8010       off12 = mips_opts.micromips;
8011       goto ld_st;
8012     case M_LDR_AB:
8013       ab = 1;
8014     case M_LDR_OB:
8015       s = "ldr";
8016       fmt = MEM12_FMT;
8017       off12 = mips_opts.micromips;
8018       goto ld_st;
8019     case M_LL_AB:
8020       ab = 1;
8021     case M_LL_OB:
8022       s = "ll";
8023       fmt = MEM12_FMT;
8024       off12 = mips_opts.micromips;
8025       goto ld;
8026     case M_LLD_AB:
8027       ab = 1;
8028     case M_LLD_OB:
8029       s = "lld";
8030       fmt = MEM12_FMT;
8031       off12 = mips_opts.micromips;
8032       goto ld;
8033     case M_LWU_AB:
8034       ab = 1;
8035     case M_LWU_OB:
8036       s = "lwu";
8037       fmt = MEM12_FMT;
8038       off12 = mips_opts.micromips;
8039       goto ld;
8040     case M_LWP_AB:
8041       ab = 1;
8042     case M_LWP_OB:
8043       gas_assert (mips_opts.micromips);
8044       s = "lwp";
8045       fmt = "t,~(b)";
8046       off12 = 1;
8047       lp = 1;
8048       goto ld;
8049     case M_LDP_AB:
8050       ab = 1;
8051     case M_LDP_OB:
8052       gas_assert (mips_opts.micromips);
8053       s = "ldp";
8054       fmt = "t,~(b)";
8055       off12 = 1;
8056       lp = 1;
8057       goto ld;
8058     case M_LWM_AB:
8059       ab = 1;
8060     case M_LWM_OB:
8061       gas_assert (mips_opts.micromips);
8062       s = "lwm";
8063       fmt = "n,~(b)";
8064       off12 = 1;
8065       goto ld_st;
8066     case M_LDM_AB:
8067       ab = 1;
8068     case M_LDM_OB:
8069       gas_assert (mips_opts.micromips);
8070       s = "ldm";
8071       fmt = "n,~(b)";
8072       off12 = 1;
8073       goto ld_st;
8074
8075     ld:
8076       if (breg == treg + lp)
8077         goto ld_st;
8078       else
8079         tempreg = treg + lp;
8080       goto ld_noat;
8081
8082     case M_SB_AB:
8083       ab = 1;
8084       s = "sb";
8085       fmt = "t,o(b)";
8086       goto ld_st;
8087     case M_SH_AB:
8088       ab = 1;
8089       s = "sh";
8090       fmt = "t,o(b)";
8091       goto ld_st;
8092     case M_SW_AB:
8093       ab = 1;
8094       s = "sw";
8095       fmt = "t,o(b)";
8096       goto ld_st;
8097     case M_SWC0_AB:
8098       ab = 1;
8099       gas_assert (!mips_opts.micromips);
8100       s = "swc0";
8101       fmt = "E,o(b)";
8102       /* Itbl support may require additional care here.  */
8103       coproc = 1;
8104       goto ld_st;
8105     case M_SWC1_AB:
8106       ab = 1;
8107       s = "swc1";
8108       fmt = "T,o(b)";
8109       /* Itbl support may require additional care here.  */
8110       coproc = 1;
8111       goto ld_st;
8112     case M_SWC2_AB:
8113       ab = 1;
8114     case M_SWC2_OB:
8115       s = "swc2";
8116       fmt = COP12_FMT;
8117       off12 = mips_opts.micromips;
8118       /* Itbl support may require additional care here.  */
8119       coproc = 1;
8120       goto ld_st;
8121     case M_SWC3_AB:
8122       ab = 1;
8123       gas_assert (!mips_opts.micromips);
8124       s = "swc3";
8125       fmt = "E,o(b)";
8126       /* Itbl support may require additional care here.  */
8127       coproc = 1;
8128       goto ld_st;
8129     case M_SWL_AB:
8130       ab = 1;
8131     case M_SWL_OB:
8132       s = "swl";
8133       fmt = MEM12_FMT;
8134       off12 = mips_opts.micromips;
8135       goto ld_st;
8136     case M_SWR_AB:
8137       ab = 1;
8138     case M_SWR_OB:
8139       s = "swr";
8140       fmt = MEM12_FMT;
8141       off12 = mips_opts.micromips;
8142       goto ld_st;
8143     case M_SC_AB:
8144       ab = 1;
8145     case M_SC_OB:
8146       s = "sc";
8147       fmt = MEM12_FMT;
8148       off12 = mips_opts.micromips;
8149       goto ld_st;
8150     case M_SCD_AB:
8151       ab = 1;
8152     case M_SCD_OB:
8153       s = "scd";
8154       fmt = MEM12_FMT;
8155       off12 = mips_opts.micromips;
8156       goto ld_st;
8157     case M_CACHE_AB:
8158       ab = 1;
8159     case M_CACHE_OB:
8160       s = "cache";
8161       fmt = mips_opts.micromips ? "k,~(b)" : "k,o(b)";
8162       off12 = mips_opts.micromips;
8163       goto ld_st;
8164     case M_PREF_AB:
8165       ab = 1;
8166     case M_PREF_OB:
8167       s = "pref";
8168       fmt = !mips_opts.micromips ? "k,o(b)" : "k,~(b)";
8169       off12 = mips_opts.micromips;
8170       goto ld_st;
8171     case M_SDC1_AB:
8172       ab = 1;
8173       s = "sdc1";
8174       fmt = "T,o(b)";
8175       coproc = 1;
8176       /* Itbl support may require additional care here.  */
8177       goto ld_st;
8178     case M_SDC2_AB:
8179       ab = 1;
8180     case M_SDC2_OB:
8181       s = "sdc2";
8182       fmt = COP12_FMT;
8183       off12 = mips_opts.micromips;
8184       /* Itbl support may require additional care here.  */
8185       coproc = 1;
8186       goto ld_st;
8187     case M_SDC3_AB:
8188       ab = 1;
8189       gas_assert (!mips_opts.micromips);
8190       s = "sdc3";
8191       fmt = "E,o(b)";
8192       /* Itbl support may require additional care here.  */
8193       coproc = 1;
8194       goto ld_st;
8195     case M_SDL_AB:
8196       ab = 1;
8197     case M_SDL_OB:
8198       s = "sdl";
8199       fmt = MEM12_FMT;
8200       off12 = mips_opts.micromips;
8201       goto ld_st;
8202     case M_SDR_AB:
8203       ab = 1;
8204     case M_SDR_OB:
8205       s = "sdr";
8206       fmt = MEM12_FMT;
8207       off12 = mips_opts.micromips;
8208       goto ld_st;
8209     case M_SWP_AB:
8210       ab = 1;
8211     case M_SWP_OB:
8212       gas_assert (mips_opts.micromips);
8213       s = "swp";
8214       fmt = "t,~(b)";
8215       off12 = 1;
8216       goto ld_st;
8217     case M_SDP_AB:
8218       ab = 1;
8219     case M_SDP_OB:
8220       gas_assert (mips_opts.micromips);
8221       s = "sdp";
8222       fmt = "t,~(b)";
8223       off12 = 1;
8224       goto ld_st;
8225     case M_SWM_AB:
8226       ab = 1;
8227     case M_SWM_OB:
8228       gas_assert (mips_opts.micromips);
8229       s = "swm";
8230       fmt = "n,~(b)";
8231       off12 = 1;
8232       goto ld_st;
8233     case M_SDM_AB:
8234       ab = 1;
8235     case M_SDM_OB:
8236       gas_assert (mips_opts.micromips);
8237       s = "sdm";
8238       fmt = "n,~(b)";
8239       off12 = 1;
8240
8241     ld_st:
8242       tempreg = AT;
8243       used_at = 1;
8244     ld_noat:
8245       if (coproc
8246           && NO_ISA_COP (mips_opts.arch)
8247           && (ip->insn_mo->pinfo2 & (INSN2_M_FP_S | INSN2_M_FP_D)) == 0)
8248         {
8249           as_bad (_("Opcode not supported on this processor: %s"),
8250                   mips_cpu_info_from_arch (mips_opts.arch)->name);
8251           break;
8252         }
8253
8254       if (offset_expr.X_op != O_constant
8255           && offset_expr.X_op != O_symbol)
8256         {
8257           as_bad (_("Expression too complex"));
8258           offset_expr.X_op = O_constant;
8259         }
8260
8261       if (HAVE_32BIT_ADDRESSES
8262           && !IS_SEXT_32BIT_NUM (offset_expr.X_add_number))
8263         {
8264           char value [32];
8265
8266           sprintf_vma (value, offset_expr.X_add_number);
8267           as_bad (_("Number (0x%s) larger than 32 bits"), value);
8268         }
8269
8270       /* A constant expression in PIC code can be handled just as it
8271          is in non PIC code.  */
8272       if (offset_expr.X_op == O_constant)
8273         {
8274           int hipart = 0;
8275
8276           expr1.X_add_number = offset_expr.X_add_number;
8277           normalize_address_expr (&expr1);
8278           if (!off12 && !IS_SEXT_16BIT_NUM (expr1.X_add_number))
8279             {
8280               expr1.X_add_number = ((expr1.X_add_number + 0x8000)
8281                                     & ~(bfd_vma) 0xffff);
8282               hipart = 1;
8283             }
8284           else if (off12 && !IS_SEXT_12BIT_NUM (expr1.X_add_number))
8285             {
8286               expr1.X_add_number = ((expr1.X_add_number + 0x800)
8287                                     & ~(bfd_vma) 0xfff);
8288               hipart = 1;
8289             }
8290           if (hipart)
8291             {
8292               load_register (tempreg, &expr1, HAVE_64BIT_ADDRESSES);
8293               if (breg != 0)
8294                 macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8295                              tempreg, tempreg, breg);
8296               breg = tempreg;
8297             }
8298           if (!off12)
8299             macro_build (&offset_expr, s, fmt, treg, BFD_RELOC_LO16, breg);
8300           else
8301             macro_build (NULL, s, fmt,
8302                          treg, (unsigned long) offset_expr.X_add_number, breg);
8303         }
8304       else if (off12)
8305         {
8306           /* A 12-bit offset field is too narrow to be used for a low-part
8307              relocation, so load the whole address into the auxillary
8308              register.  In the case of "A(b)" addresses, we first load
8309              absolute address "A" into the register and then add base
8310              register "b".  In the case of "o(b)" addresses, we simply
8311              need to add 16-bit offset "o" to base register "b", and
8312              offset_reloc already contains the relocations associated
8313              with "o".  */
8314           if (ab)
8315             {
8316               load_address (tempreg, &offset_expr, &used_at);
8317               if (breg != 0)
8318                 macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8319                              tempreg, tempreg, breg);
8320             }
8321           else
8322             macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
8323                          tempreg, breg, -1,
8324                          offset_reloc[0], offset_reloc[1], offset_reloc[2]);
8325           expr1.X_add_number = 0;
8326           macro_build (NULL, s, fmt,
8327                        treg, (unsigned long) expr1.X_add_number, tempreg);
8328         }
8329       else if (mips_pic == NO_PIC)
8330         {
8331           /* If this is a reference to a GP relative symbol, and there
8332              is no base register, we want
8333                <op>     $treg,<sym>($gp)        (BFD_RELOC_GPREL16)
8334              Otherwise, if there is no base register, we want
8335                lui      $tempreg,<sym>          (BFD_RELOC_HI16_S)
8336                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
8337              If we have a constant, we need two instructions anyhow,
8338              so we always use the latter form.
8339
8340              If we have a base register, and this is a reference to a
8341              GP relative symbol, we want
8342                addu     $tempreg,$breg,$gp
8343                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_GPREL16)
8344              Otherwise we want
8345                lui      $tempreg,<sym>          (BFD_RELOC_HI16_S)
8346                addu     $tempreg,$tempreg,$breg
8347                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
8348              With a constant we always use the latter case.
8349
8350              With 64bit address space and no base register and $at usable,
8351              we want
8352                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
8353                lui      $at,<sym>               (BFD_RELOC_HI16_S)
8354                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
8355                dsll32   $tempreg,0
8356                daddu    $tempreg,$at
8357                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
8358              If we have a base register, we want
8359                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
8360                lui      $at,<sym>               (BFD_RELOC_HI16_S)
8361                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
8362                daddu    $at,$breg
8363                dsll32   $tempreg,0
8364                daddu    $tempreg,$at
8365                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
8366
8367              Without $at we can't generate the optimal path for superscalar
8368              processors here since this would require two temporary registers.
8369                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
8370                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
8371                dsll     $tempreg,16
8372                daddiu   $tempreg,<sym>          (BFD_RELOC_HI16_S)
8373                dsll     $tempreg,16
8374                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
8375              If we have a base register, we want
8376                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
8377                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
8378                dsll     $tempreg,16
8379                daddiu   $tempreg,<sym>          (BFD_RELOC_HI16_S)
8380                dsll     $tempreg,16
8381                daddu    $tempreg,$tempreg,$breg
8382                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
8383
8384              For GP relative symbols in 64bit address space we can use
8385              the same sequence as in 32bit address space.  */
8386           if (HAVE_64BIT_SYMBOLS)
8387             {
8388               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
8389                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
8390                 {
8391                   relax_start (offset_expr.X_add_symbol);
8392                   if (breg == 0)
8393                     {
8394                       macro_build (&offset_expr, s, fmt, treg,
8395                                    BFD_RELOC_GPREL16, mips_gp_register);
8396                     }
8397                   else
8398                     {
8399                       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8400                                    tempreg, breg, mips_gp_register);
8401                       macro_build (&offset_expr, s, fmt, treg,
8402                                    BFD_RELOC_GPREL16, tempreg);
8403                     }
8404                   relax_switch ();
8405                 }
8406
8407               if (used_at == 0 && mips_opts.at)
8408                 {
8409                   macro_build (&offset_expr, "lui", LUI_FMT, tempreg,
8410                                BFD_RELOC_MIPS_HIGHEST);
8411                   macro_build (&offset_expr, "lui", LUI_FMT, AT,
8412                                BFD_RELOC_HI16_S);
8413                   macro_build (&offset_expr, "daddiu", "t,r,j", tempreg,
8414                                tempreg, BFD_RELOC_MIPS_HIGHER);
8415                   if (breg != 0)
8416                     macro_build (NULL, "daddu", "d,v,t", AT, AT, breg);
8417                   macro_build (NULL, "dsll32", SHFT_FMT, tempreg, tempreg, 0);
8418                   macro_build (NULL, "daddu", "d,v,t", tempreg, tempreg, AT);
8419                   macro_build (&offset_expr, s, fmt, treg, BFD_RELOC_LO16,
8420                                tempreg);
8421                   used_at = 1;
8422                 }
8423               else
8424                 {
8425                   macro_build (&offset_expr, "lui", LUI_FMT, tempreg,
8426                                BFD_RELOC_MIPS_HIGHEST);
8427                   macro_build (&offset_expr, "daddiu", "t,r,j", tempreg,
8428                                tempreg, BFD_RELOC_MIPS_HIGHER);
8429                   macro_build (NULL, "dsll", SHFT_FMT, tempreg, tempreg, 16);
8430                   macro_build (&offset_expr, "daddiu", "t,r,j", tempreg,
8431                                tempreg, BFD_RELOC_HI16_S);
8432                   macro_build (NULL, "dsll", SHFT_FMT, tempreg, tempreg, 16);
8433                   if (breg != 0)
8434                     macro_build (NULL, "daddu", "d,v,t",
8435                                  tempreg, tempreg, breg);
8436                   macro_build (&offset_expr, s, fmt, treg,
8437                                BFD_RELOC_LO16, tempreg);
8438                 }
8439
8440               if (mips_relax.sequence)
8441                 relax_end ();
8442               break;
8443             }
8444
8445           if (breg == 0)
8446             {
8447               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
8448                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
8449                 {
8450                   relax_start (offset_expr.X_add_symbol);
8451                   macro_build (&offset_expr, s, fmt, treg, BFD_RELOC_GPREL16,
8452                                mips_gp_register);
8453                   relax_switch ();
8454                 }
8455               macro_build_lui (&offset_expr, tempreg);
8456               macro_build (&offset_expr, s, fmt, treg,
8457                            BFD_RELOC_LO16, tempreg);
8458               if (mips_relax.sequence)
8459                 relax_end ();
8460             }
8461           else
8462             {
8463               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
8464                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
8465                 {
8466                   relax_start (offset_expr.X_add_symbol);
8467                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8468                                tempreg, breg, mips_gp_register);
8469                   macro_build (&offset_expr, s, fmt, treg,
8470                                BFD_RELOC_GPREL16, tempreg);
8471                   relax_switch ();
8472                 }
8473               macro_build_lui (&offset_expr, tempreg);
8474               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8475                            tempreg, tempreg, breg);
8476               macro_build (&offset_expr, s, fmt, treg,
8477                            BFD_RELOC_LO16, tempreg);
8478               if (mips_relax.sequence)
8479                 relax_end ();
8480             }
8481         }
8482       else if (!mips_big_got)
8483         {
8484           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT16;
8485
8486           /* If this is a reference to an external symbol, we want
8487                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
8488                nop
8489                <op>     $treg,0($tempreg)
8490              Otherwise we want
8491                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
8492                nop
8493                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
8494                <op>     $treg,0($tempreg)
8495
8496              For NewABI, we want
8497                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_PAGE)
8498                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_MIPS_GOT_OFST)
8499
8500              If there is a base register, we add it to $tempreg before
8501              the <op>.  If there is a constant, we stick it in the
8502              <op> instruction.  We don't handle constants larger than
8503              16 bits, because we have no way to load the upper 16 bits
8504              (actually, we could handle them for the subset of cases
8505              in which we are not using $at).  */
8506           gas_assert (offset_expr.X_op == O_symbol);
8507           if (HAVE_NEWABI)
8508             {
8509               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
8510                            BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
8511               if (breg != 0)
8512                 macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8513                              tempreg, tempreg, breg);
8514               macro_build (&offset_expr, s, fmt, treg,
8515                            BFD_RELOC_MIPS_GOT_OFST, tempreg);
8516               break;
8517             }
8518           expr1.X_add_number = offset_expr.X_add_number;
8519           offset_expr.X_add_number = 0;
8520           if (expr1.X_add_number < -0x8000
8521               || expr1.X_add_number >= 0x8000)
8522             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
8523           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
8524                        lw_reloc_type, mips_gp_register);
8525           load_delay_nop ();
8526           relax_start (offset_expr.X_add_symbol);
8527           relax_switch ();
8528           macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j", tempreg,
8529                        tempreg, BFD_RELOC_LO16);
8530           relax_end ();
8531           if (breg != 0)
8532             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8533                          tempreg, tempreg, breg);
8534           macro_build (&expr1, s, fmt, treg, BFD_RELOC_LO16, tempreg);
8535         }
8536       else if (mips_big_got && !HAVE_NEWABI)
8537         {
8538           int gpdelay;
8539
8540           /* If this is a reference to an external symbol, we want
8541                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
8542                addu     $tempreg,$tempreg,$gp
8543                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
8544                <op>     $treg,0($tempreg)
8545              Otherwise we want
8546                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
8547                nop
8548                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
8549                <op>     $treg,0($tempreg)
8550              If there is a base register, we add it to $tempreg before
8551              the <op>.  If there is a constant, we stick it in the
8552              <op> instruction.  We don't handle constants larger than
8553              16 bits, because we have no way to load the upper 16 bits
8554              (actually, we could handle them for the subset of cases
8555              in which we are not using $at).  */
8556           gas_assert (offset_expr.X_op == O_symbol);
8557           expr1.X_add_number = offset_expr.X_add_number;
8558           offset_expr.X_add_number = 0;
8559           if (expr1.X_add_number < -0x8000
8560               || expr1.X_add_number >= 0x8000)
8561             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
8562           gpdelay = reg_needs_delay (mips_gp_register);
8563           relax_start (offset_expr.X_add_symbol);
8564           macro_build (&offset_expr, "lui", LUI_FMT, tempreg,
8565                        BFD_RELOC_MIPS_GOT_HI16);
8566           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", tempreg, tempreg,
8567                        mips_gp_register);
8568           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
8569                        BFD_RELOC_MIPS_GOT_LO16, tempreg);
8570           relax_switch ();
8571           if (gpdelay)
8572             macro_build (NULL, "nop", "");
8573           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
8574                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
8575           load_delay_nop ();
8576           macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j", tempreg,
8577                        tempreg, BFD_RELOC_LO16);
8578           relax_end ();
8579
8580           if (breg != 0)
8581             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8582                          tempreg, tempreg, breg);
8583           macro_build (&expr1, s, fmt, treg, BFD_RELOC_LO16, tempreg);
8584         }
8585       else if (mips_big_got && HAVE_NEWABI)
8586         {
8587           /* If this is a reference to an external symbol, we want
8588                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
8589                add      $tempreg,$tempreg,$gp
8590                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
8591                <op>     $treg,<ofst>($tempreg)
8592              Otherwise, for local symbols, we want:
8593                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_PAGE)
8594                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_MIPS_GOT_OFST)  */
8595           gas_assert (offset_expr.X_op == O_symbol);
8596           expr1.X_add_number = offset_expr.X_add_number;
8597           offset_expr.X_add_number = 0;
8598           if (expr1.X_add_number < -0x8000
8599               || expr1.X_add_number >= 0x8000)
8600             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
8601           relax_start (offset_expr.X_add_symbol);
8602           macro_build (&offset_expr, "lui", LUI_FMT, tempreg,
8603                        BFD_RELOC_MIPS_GOT_HI16);
8604           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", tempreg, tempreg,
8605                        mips_gp_register);
8606           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
8607                        BFD_RELOC_MIPS_GOT_LO16, tempreg);
8608           if (breg != 0)
8609             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8610                          tempreg, tempreg, breg);
8611           macro_build (&expr1, s, fmt, treg, BFD_RELOC_LO16, tempreg);
8612
8613           relax_switch ();
8614           offset_expr.X_add_number = expr1.X_add_number;
8615           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
8616                        BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
8617           if (breg != 0)
8618             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8619                          tempreg, tempreg, breg);
8620           macro_build (&offset_expr, s, fmt, treg,
8621                        BFD_RELOC_MIPS_GOT_OFST, tempreg);
8622           relax_end ();
8623         }
8624       else
8625         abort ();
8626
8627       break;
8628
8629     case M_LI:
8630     case M_LI_S:
8631       load_register (treg, &imm_expr, 0);
8632       break;
8633
8634     case M_DLI:
8635       load_register (treg, &imm_expr, 1);
8636       break;
8637
8638     case M_LI_SS:
8639       if (imm_expr.X_op == O_constant)
8640         {
8641           used_at = 1;
8642           load_register (AT, &imm_expr, 0);
8643           macro_build (NULL, "mtc1", "t,G", AT, treg);
8644           break;
8645         }
8646       else
8647         {
8648           gas_assert (offset_expr.X_op == O_symbol
8649                       && strcmp (segment_name (S_GET_SEGMENT
8650                                                (offset_expr.X_add_symbol)),
8651                                  ".lit4") == 0
8652                       && offset_expr.X_add_number == 0);
8653           macro_build (&offset_expr, "lwc1", "T,o(b)", treg,
8654                        BFD_RELOC_MIPS_LITERAL, mips_gp_register);
8655           break;
8656         }
8657
8658     case M_LI_D:
8659       /* Check if we have a constant in IMM_EXPR.  If the GPRs are 64 bits
8660          wide, IMM_EXPR is the entire value.  Otherwise IMM_EXPR is the high
8661          order 32 bits of the value and the low order 32 bits are either
8662          zero or in OFFSET_EXPR.  */
8663       if (imm_expr.X_op == O_constant || imm_expr.X_op == O_big)
8664         {
8665           if (HAVE_64BIT_GPRS)
8666             load_register (treg, &imm_expr, 1);
8667           else
8668             {
8669               int hreg, lreg;
8670
8671               if (target_big_endian)
8672                 {
8673                   hreg = treg;
8674                   lreg = treg + 1;
8675                 }
8676               else
8677                 {
8678                   hreg = treg + 1;
8679                   lreg = treg;
8680                 }
8681
8682               if (hreg <= 31)
8683                 load_register (hreg, &imm_expr, 0);
8684               if (lreg <= 31)
8685                 {
8686                   if (offset_expr.X_op == O_absent)
8687                     move_register (lreg, 0);
8688                   else
8689                     {
8690                       gas_assert (offset_expr.X_op == O_constant);
8691                       load_register (lreg, &offset_expr, 0);
8692                     }
8693                 }
8694             }
8695           break;
8696         }
8697
8698       /* We know that sym is in the .rdata section.  First we get the
8699          upper 16 bits of the address.  */
8700       if (mips_pic == NO_PIC)
8701         {
8702           macro_build_lui (&offset_expr, AT);
8703           used_at = 1;
8704         }
8705       else
8706         {
8707           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", AT,
8708                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
8709           used_at = 1;
8710         }
8711
8712       /* Now we load the register(s).  */
8713       if (HAVE_64BIT_GPRS)
8714         {
8715           used_at = 1;
8716           macro_build (&offset_expr, "ld", "t,o(b)", treg, BFD_RELOC_LO16, AT);
8717         }
8718       else
8719         {
8720           used_at = 1;
8721           macro_build (&offset_expr, "lw", "t,o(b)", treg, BFD_RELOC_LO16, AT);
8722           if (treg != RA)
8723             {
8724               /* FIXME: How in the world do we deal with the possible
8725                  overflow here?  */
8726               offset_expr.X_add_number += 4;
8727               macro_build (&offset_expr, "lw", "t,o(b)",
8728                            treg + 1, BFD_RELOC_LO16, AT);
8729             }
8730         }
8731       break;
8732
8733     case M_LI_DD:
8734       /* Check if we have a constant in IMM_EXPR.  If the FPRs are 64 bits
8735          wide, IMM_EXPR is the entire value and the GPRs are known to be 64
8736          bits wide as well.  Otherwise IMM_EXPR is the high order 32 bits of
8737          the value and the low order 32 bits are either zero or in
8738          OFFSET_EXPR.  */
8739       if (imm_expr.X_op == O_constant || imm_expr.X_op == O_big)
8740         {
8741           used_at = 1;
8742           load_register (AT, &imm_expr, HAVE_64BIT_FPRS);
8743           if (HAVE_64BIT_FPRS)
8744             {
8745               gas_assert (HAVE_64BIT_GPRS);
8746               macro_build (NULL, "dmtc1", "t,S", AT, treg);
8747             }
8748           else
8749             {
8750               macro_build (NULL, "mtc1", "t,G", AT, treg + 1);
8751               if (offset_expr.X_op == O_absent)
8752                 macro_build (NULL, "mtc1", "t,G", 0, treg);
8753               else
8754                 {
8755                   gas_assert (offset_expr.X_op == O_constant);
8756                   load_register (AT, &offset_expr, 0);
8757                   macro_build (NULL, "mtc1", "t,G", AT, treg);
8758                 }
8759             }
8760           break;
8761         }
8762
8763       gas_assert (offset_expr.X_op == O_symbol
8764                   && offset_expr.X_add_number == 0);
8765       s = segment_name (S_GET_SEGMENT (offset_expr.X_add_symbol));
8766       if (strcmp (s, ".lit8") == 0)
8767         {
8768           if (mips_opts.isa != ISA_MIPS1 || mips_opts.micromips)
8769             {
8770               macro_build (&offset_expr, "ldc1", "T,o(b)", treg,
8771                            BFD_RELOC_MIPS_LITERAL, mips_gp_register);
8772               break;
8773             }
8774           breg = mips_gp_register;
8775           r = BFD_RELOC_MIPS_LITERAL;
8776           goto dob;
8777         }
8778       else
8779         {
8780           gas_assert (strcmp (s, RDATA_SECTION_NAME) == 0);
8781           used_at = 1;
8782           if (mips_pic != NO_PIC)
8783             macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", AT,
8784                          BFD_RELOC_MIPS_GOT16, mips_gp_register);
8785           else
8786             {
8787               /* FIXME: This won't work for a 64 bit address.  */
8788               macro_build_lui (&offset_expr, AT);
8789             }
8790
8791           if (mips_opts.isa != ISA_MIPS1 || mips_opts.micromips)
8792             {
8793               macro_build (&offset_expr, "ldc1", "T,o(b)",
8794                            treg, BFD_RELOC_LO16, AT);
8795               break;
8796             }
8797           breg = AT;
8798           r = BFD_RELOC_LO16;
8799           goto dob;
8800         }
8801
8802     case M_L_DOB:
8803       /* Even on a big endian machine $fn comes before $fn+1.  We have
8804          to adjust when loading from memory.  */
8805       r = BFD_RELOC_LO16;
8806     dob:
8807       gas_assert (!mips_opts.micromips);
8808       gas_assert (mips_opts.isa == ISA_MIPS1);
8809       macro_build (&offset_expr, "lwc1", "T,o(b)",
8810                    target_big_endian ? treg + 1 : treg, r, breg);
8811       /* FIXME: A possible overflow which I don't know how to deal
8812          with.  */
8813       offset_expr.X_add_number += 4;
8814       macro_build (&offset_expr, "lwc1", "T,o(b)",
8815                    target_big_endian ? treg : treg + 1, r, breg);
8816       break;
8817
8818     case M_S_DOB:
8819       gas_assert (!mips_opts.micromips);
8820       gas_assert (mips_opts.isa == ISA_MIPS1);
8821       /* Even on a big endian machine $fn comes before $fn+1.  We have
8822          to adjust when storing to memory.  */
8823       macro_build (&offset_expr, "swc1", "T,o(b)",
8824                    target_big_endian ? treg + 1 : treg, BFD_RELOC_LO16, breg);
8825       offset_expr.X_add_number += 4;
8826       macro_build (&offset_expr, "swc1", "T,o(b)",
8827                    target_big_endian ? treg : treg + 1, BFD_RELOC_LO16, breg);
8828       break;
8829
8830     case M_L_DAB:
8831       gas_assert (!mips_opts.micromips);
8832       /*
8833        * The MIPS assembler seems to check for X_add_number not
8834        * being double aligned and generating:
8835        *        lui     at,%hi(foo+1)
8836        *        addu    at,at,v1
8837        *        addiu   at,at,%lo(foo+1)
8838        *        lwc1    f2,0(at)
8839        *        lwc1    f3,4(at)
8840        * But, the resulting address is the same after relocation so why
8841        * generate the extra instruction?
8842        */
8843       /* Itbl support may require additional care here.  */
8844       coproc = 1;
8845       fmt = "T,o(b)";
8846       if (mips_opts.isa != ISA_MIPS1)
8847         {
8848           s = "ldc1";
8849           goto ld_st;
8850         }
8851       s = "lwc1";
8852       goto ldd_std;
8853
8854     case M_S_DAB:
8855       gas_assert (!mips_opts.micromips);
8856       /* Itbl support may require additional care here.  */
8857       coproc = 1;
8858       fmt = "T,o(b)";
8859       if (mips_opts.isa != ISA_MIPS1)
8860         {
8861           s = "sdc1";
8862           goto ld_st;
8863         }
8864       s = "swc1";
8865       goto ldd_std;
8866
8867     case M_LD_AB:
8868       fmt = "t,o(b)";
8869       if (HAVE_64BIT_GPRS)
8870         {
8871           s = "ld";
8872           goto ld;
8873         }
8874       s = "lw";
8875       goto ldd_std;
8876
8877     case M_SD_AB:
8878       fmt = "t,o(b)";
8879       if (HAVE_64BIT_GPRS)
8880         {
8881           s = "sd";
8882           goto ld_st;
8883         }
8884       s = "sw";
8885
8886     ldd_std:
8887       if (offset_expr.X_op != O_symbol
8888           && offset_expr.X_op != O_constant)
8889         {
8890           as_bad (_("Expression too complex"));
8891           offset_expr.X_op = O_constant;
8892         }
8893
8894       if (HAVE_32BIT_ADDRESSES
8895           && !IS_SEXT_32BIT_NUM (offset_expr.X_add_number))
8896         {
8897           char value [32];
8898
8899           sprintf_vma (value, offset_expr.X_add_number);
8900           as_bad (_("Number (0x%s) larger than 32 bits"), value);
8901         }
8902
8903       /* Even on a big endian machine $fn comes before $fn+1.  We have
8904          to adjust when loading from memory.  We set coproc if we must
8905          load $fn+1 first.  */
8906       /* Itbl support may require additional care here.  */
8907       if (!target_big_endian)
8908         coproc = 0;
8909
8910       if (mips_pic == NO_PIC || offset_expr.X_op == O_constant)
8911         {
8912           /* If this is a reference to a GP relative symbol, we want
8913                <op>     $treg,<sym>($gp)        (BFD_RELOC_GPREL16)
8914                <op>     $treg+1,<sym>+4($gp)    (BFD_RELOC_GPREL16)
8915              If we have a base register, we use this
8916                addu     $at,$breg,$gp
8917                <op>     $treg,<sym>($at)        (BFD_RELOC_GPREL16)
8918                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_GPREL16)
8919              If this is not a GP relative symbol, we want
8920                lui      $at,<sym>               (BFD_RELOC_HI16_S)
8921                <op>     $treg,<sym>($at)        (BFD_RELOC_LO16)
8922                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_LO16)
8923              If there is a base register, we add it to $at after the
8924              lui instruction.  If there is a constant, we always use
8925              the last case.  */
8926           if (offset_expr.X_op == O_symbol
8927               && (valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
8928               && !nopic_need_relax (offset_expr.X_add_symbol, 1))
8929             {
8930               relax_start (offset_expr.X_add_symbol);
8931               if (breg == 0)
8932                 {
8933                   tempreg = mips_gp_register;
8934                 }
8935               else
8936                 {
8937                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
8938                                AT, breg, mips_gp_register);
8939                   tempreg = AT;
8940                   used_at = 1;
8941                 }
8942
8943               /* Itbl support may require additional care here.  */
8944               macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
8945                            BFD_RELOC_GPREL16, tempreg);
8946               offset_expr.X_add_number += 4;
8947
8948               /* Set mips_optimize to 2 to avoid inserting an
8949                  undesired nop.  */
8950               hold_mips_optimize = mips_optimize;
8951               mips_optimize = 2;
8952               /* Itbl support may require additional care here.  */
8953               macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
8954                            BFD_RELOC_GPREL16, tempreg);
8955               mips_optimize = hold_mips_optimize;
8956
8957               relax_switch ();
8958
8959               offset_expr.X_add_number -= 4;
8960             }
8961           used_at = 1;
8962           macro_build_lui (&offset_expr, AT);
8963           if (breg != 0)
8964             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
8965           /* Itbl support may require additional care here.  */
8966           macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
8967                        BFD_RELOC_LO16, AT);
8968           /* FIXME: How do we handle overflow here?  */
8969           offset_expr.X_add_number += 4;
8970           /* Itbl support may require additional care here.  */
8971           macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
8972                        BFD_RELOC_LO16, AT);
8973           if (mips_relax.sequence)
8974             relax_end ();
8975         }
8976       else if (!mips_big_got)
8977         {
8978           /* If this is a reference to an external symbol, we want
8979                lw       $at,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
8980                nop
8981                <op>     $treg,0($at)
8982                <op>     $treg+1,4($at)
8983              Otherwise we want
8984                lw       $at,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
8985                nop
8986                <op>     $treg,<sym>($at)        (BFD_RELOC_LO16)
8987                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_LO16)
8988              If there is a base register we add it to $at before the
8989              lwc1 instructions.  If there is a constant we include it
8990              in the lwc1 instructions.  */
8991           used_at = 1;
8992           expr1.X_add_number = offset_expr.X_add_number;
8993           if (expr1.X_add_number < -0x8000
8994               || expr1.X_add_number >= 0x8000 - 4)
8995             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
8996           load_got_offset (AT, &offset_expr);
8997           load_delay_nop ();
8998           if (breg != 0)
8999             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
9000
9001           /* Set mips_optimize to 2 to avoid inserting an undesired
9002              nop.  */
9003           hold_mips_optimize = mips_optimize;
9004           mips_optimize = 2;
9005
9006           /* Itbl support may require additional care here.  */
9007           relax_start (offset_expr.X_add_symbol);
9008           macro_build (&expr1, s, fmt, coproc ? treg + 1 : treg,
9009                        BFD_RELOC_LO16, AT);
9010           expr1.X_add_number += 4;
9011           macro_build (&expr1, s, fmt, coproc ? treg : treg + 1,
9012                        BFD_RELOC_LO16, AT);
9013           relax_switch ();
9014           macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
9015                        BFD_RELOC_LO16, AT);
9016           offset_expr.X_add_number += 4;
9017           macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
9018                        BFD_RELOC_LO16, AT);
9019           relax_end ();
9020
9021           mips_optimize = hold_mips_optimize;
9022         }
9023       else if (mips_big_got)
9024         {
9025           int gpdelay;
9026
9027           /* If this is a reference to an external symbol, we want
9028                lui      $at,<sym>               (BFD_RELOC_MIPS_GOT_HI16)
9029                addu     $at,$at,$gp
9030                lw       $at,<sym>($at)          (BFD_RELOC_MIPS_GOT_LO16)
9031                nop
9032                <op>     $treg,0($at)
9033                <op>     $treg+1,4($at)
9034              Otherwise we want
9035                lw       $at,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
9036                nop
9037                <op>     $treg,<sym>($at)        (BFD_RELOC_LO16)
9038                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_LO16)
9039              If there is a base register we add it to $at before the
9040              lwc1 instructions.  If there is a constant we include it
9041              in the lwc1 instructions.  */
9042           used_at = 1;
9043           expr1.X_add_number = offset_expr.X_add_number;
9044           offset_expr.X_add_number = 0;
9045           if (expr1.X_add_number < -0x8000
9046               || expr1.X_add_number >= 0x8000 - 4)
9047             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
9048           gpdelay = reg_needs_delay (mips_gp_register);
9049           relax_start (offset_expr.X_add_symbol);
9050           macro_build (&offset_expr, "lui", LUI_FMT,
9051                        AT, BFD_RELOC_MIPS_GOT_HI16);
9052           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
9053                        AT, AT, mips_gp_register);
9054           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
9055                        AT, BFD_RELOC_MIPS_GOT_LO16, AT);
9056           load_delay_nop ();
9057           if (breg != 0)
9058             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
9059           /* Itbl support may require additional care here.  */
9060           macro_build (&expr1, s, fmt, coproc ? treg + 1 : treg,
9061                        BFD_RELOC_LO16, AT);
9062           expr1.X_add_number += 4;
9063
9064           /* Set mips_optimize to 2 to avoid inserting an undesired
9065              nop.  */
9066           hold_mips_optimize = mips_optimize;
9067           mips_optimize = 2;
9068           /* Itbl support may require additional care here.  */
9069           macro_build (&expr1, s, fmt, coproc ? treg : treg + 1,
9070                        BFD_RELOC_LO16, AT);
9071           mips_optimize = hold_mips_optimize;
9072           expr1.X_add_number -= 4;
9073
9074           relax_switch ();
9075           offset_expr.X_add_number = expr1.X_add_number;
9076           if (gpdelay)
9077             macro_build (NULL, "nop", "");
9078           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", AT,
9079                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
9080           load_delay_nop ();
9081           if (breg != 0)
9082             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
9083           /* Itbl support may require additional care here.  */
9084           macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
9085                        BFD_RELOC_LO16, AT);
9086           offset_expr.X_add_number += 4;
9087
9088           /* Set mips_optimize to 2 to avoid inserting an undesired
9089              nop.  */
9090           hold_mips_optimize = mips_optimize;
9091           mips_optimize = 2;
9092           /* Itbl support may require additional care here.  */
9093           macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
9094                        BFD_RELOC_LO16, AT);
9095           mips_optimize = hold_mips_optimize;
9096           relax_end ();
9097         }
9098       else
9099         abort ();
9100
9101       break;
9102
9103     case M_LD_OB:
9104       s = HAVE_64BIT_GPRS ? "ld" : "lw";
9105       goto sd_ob;
9106     case M_SD_OB:
9107       s = HAVE_64BIT_GPRS ? "sd" : "sw";
9108     sd_ob:
9109       macro_build (&offset_expr, s, "t,o(b)", treg,
9110                    -1, offset_reloc[0], offset_reloc[1], offset_reloc[2],
9111                    breg);
9112       if (!HAVE_64BIT_GPRS)
9113         {
9114           offset_expr.X_add_number += 4;
9115           macro_build (&offset_expr, s, "t,o(b)", treg + 1,
9116                        -1, offset_reloc[0], offset_reloc[1], offset_reloc[2],
9117                        breg);
9118         }
9119       break;
9120
9121    /* New code added to support COPZ instructions.
9122       This code builds table entries out of the macros in mip_opcodes.
9123       R4000 uses interlocks to handle coproc delays.
9124       Other chips (like the R3000) require nops to be inserted for delays.
9125
9126       FIXME: Currently, we require that the user handle delays.
9127       In order to fill delay slots for non-interlocked chips,
9128       we must have a way to specify delays based on the coprocessor.
9129       Eg. 4 cycles if load coproc reg from memory, 1 if in cache, etc.
9130       What are the side-effects of the cop instruction?
9131       What cache support might we have and what are its effects?
9132       Both coprocessor & memory require delays. how long???
9133       What registers are read/set/modified?
9134
9135       If an itbl is provided to interpret cop instructions,
9136       this knowledge can be encoded in the itbl spec.  */
9137
9138     case M_COP0:
9139       s = "c0";
9140       goto copz;
9141     case M_COP1:
9142       s = "c1";
9143       goto copz;
9144     case M_COP2:
9145       s = "c2";
9146       goto copz;
9147     case M_COP3:
9148       s = "c3";
9149     copz:
9150       gas_assert (!mips_opts.micromips);
9151       if (NO_ISA_COP (mips_opts.arch)
9152           && (ip->insn_mo->pinfo2 & INSN2_M_FP_S) == 0)
9153         {
9154           as_bad (_("opcode not supported on this processor: %s"),
9155                   mips_cpu_info_from_arch (mips_opts.arch)->name);
9156           break;
9157         }
9158
9159       /* For now we just do C (same as Cz).  The parameter will be
9160          stored in insn_opcode by mips_ip.  */
9161       macro_build (NULL, s, "C", ip->insn_opcode);
9162       break;
9163
9164     case M_MOVE:
9165       move_register (dreg, sreg);
9166       break;
9167
9168     case M_DMUL:
9169       dbl = 1;
9170     case M_MUL:
9171       macro_build (NULL, dbl ? "dmultu" : "multu", "s,t", sreg, treg);
9172       macro_build (NULL, "mflo", MFHL_FMT, dreg);
9173       break;
9174
9175     case M_DMUL_I:
9176       dbl = 1;
9177     case M_MUL_I:
9178       /* The MIPS assembler some times generates shifts and adds.  I'm
9179          not trying to be that fancy. GCC should do this for us
9180          anyway.  */
9181       used_at = 1;
9182       load_register (AT, &imm_expr, dbl);
9183       macro_build (NULL, dbl ? "dmult" : "mult", "s,t", sreg, AT);
9184       macro_build (NULL, "mflo", MFHL_FMT, dreg);
9185       break;
9186
9187     case M_DMULO_I:
9188       dbl = 1;
9189     case M_MULO_I:
9190       imm = 1;
9191       goto do_mulo;
9192
9193     case M_DMULO:
9194       dbl = 1;
9195     case M_MULO:
9196     do_mulo:
9197       start_noreorder ();
9198       used_at = 1;
9199       if (imm)
9200         load_register (AT, &imm_expr, dbl);
9201       macro_build (NULL, dbl ? "dmult" : "mult", "s,t", sreg, imm ? AT : treg);
9202       macro_build (NULL, "mflo", MFHL_FMT, dreg);
9203       macro_build (NULL, dbl ? "dsra32" : "sra", SHFT_FMT, dreg, dreg, RA);
9204       macro_build (NULL, "mfhi", MFHL_FMT, AT);
9205       if (mips_trap)
9206         macro_build (NULL, "tne", TRAP_FMT, dreg, AT, 6);
9207       else
9208         {
9209           if (mips_opts.micromips)
9210             micromips_label_expr (&label_expr);
9211           else
9212             label_expr.X_add_number = 8;
9213           macro_build (&label_expr, "beq", "s,t,p", dreg, AT);
9214           macro_build (NULL, "nop", "");
9215           macro_build (NULL, "break", BRK_FMT, 6);
9216           if (mips_opts.micromips)
9217             micromips_add_label ();
9218         }
9219       end_noreorder ();
9220       macro_build (NULL, "mflo", MFHL_FMT, dreg);
9221       break;
9222
9223     case M_DMULOU_I:
9224       dbl = 1;
9225     case M_MULOU_I:
9226       imm = 1;
9227       goto do_mulou;
9228
9229     case M_DMULOU:
9230       dbl = 1;
9231     case M_MULOU:
9232     do_mulou:
9233       start_noreorder ();
9234       used_at = 1;
9235       if (imm)
9236         load_register (AT, &imm_expr, dbl);
9237       macro_build (NULL, dbl ? "dmultu" : "multu", "s,t",
9238                    sreg, imm ? AT : treg);
9239       macro_build (NULL, "mfhi", MFHL_FMT, AT);
9240       macro_build (NULL, "mflo", MFHL_FMT, dreg);
9241       if (mips_trap)
9242         macro_build (NULL, "tne", TRAP_FMT, AT, ZERO, 6);
9243       else
9244         {
9245           if (mips_opts.micromips)
9246             micromips_label_expr (&label_expr);
9247           else
9248             label_expr.X_add_number = 8;
9249           macro_build (&label_expr, "beq", "s,t,p", AT, ZERO);
9250           macro_build (NULL, "nop", "");
9251           macro_build (NULL, "break", BRK_FMT, 6);
9252           if (mips_opts.micromips)
9253             micromips_add_label ();
9254         }
9255       end_noreorder ();
9256       break;
9257
9258     case M_DROL:
9259       if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
9260         {
9261           if (dreg == sreg)
9262             {
9263               tempreg = AT;
9264               used_at = 1;
9265             }
9266           else
9267             {
9268               tempreg = dreg;
9269             }
9270           macro_build (NULL, "dnegu", "d,w", tempreg, treg);
9271           macro_build (NULL, "drorv", "d,t,s", dreg, sreg, tempreg);
9272           break;
9273         }
9274       used_at = 1;
9275       macro_build (NULL, "dsubu", "d,v,t", AT, ZERO, treg);
9276       macro_build (NULL, "dsrlv", "d,t,s", AT, sreg, AT);
9277       macro_build (NULL, "dsllv", "d,t,s", dreg, sreg, treg);
9278       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9279       break;
9280
9281     case M_ROL:
9282       if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
9283         {
9284           if (dreg == sreg)
9285             {
9286               tempreg = AT;
9287               used_at = 1;
9288             }
9289           else
9290             {
9291               tempreg = dreg;
9292             }
9293           macro_build (NULL, "negu", "d,w", tempreg, treg);
9294           macro_build (NULL, "rorv", "d,t,s", dreg, sreg, tempreg);
9295           break;
9296         }
9297       used_at = 1;
9298       macro_build (NULL, "subu", "d,v,t", AT, ZERO, treg);
9299       macro_build (NULL, "srlv", "d,t,s", AT, sreg, AT);
9300       macro_build (NULL, "sllv", "d,t,s", dreg, sreg, treg);
9301       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9302       break;
9303
9304     case M_DROL_I:
9305       {
9306         unsigned int rot;
9307         char *l;
9308         char *rr;
9309
9310         if (imm_expr.X_op != O_constant)
9311           as_bad (_("Improper rotate count"));
9312         rot = imm_expr.X_add_number & 0x3f;
9313         if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
9314           {
9315             rot = (64 - rot) & 0x3f;
9316             if (rot >= 32)
9317               macro_build (NULL, "dror32", SHFT_FMT, dreg, sreg, rot - 32);
9318             else
9319               macro_build (NULL, "dror", SHFT_FMT, dreg, sreg, rot);
9320             break;
9321           }
9322         if (rot == 0)
9323           {
9324             macro_build (NULL, "dsrl", SHFT_FMT, dreg, sreg, 0);
9325             break;
9326           }
9327         l = (rot < 0x20) ? "dsll" : "dsll32";
9328         rr = ((0x40 - rot) < 0x20) ? "dsrl" : "dsrl32";
9329         rot &= 0x1f;
9330         used_at = 1;
9331         macro_build (NULL, l, SHFT_FMT, AT, sreg, rot);
9332         macro_build (NULL, rr, SHFT_FMT, dreg, sreg, (0x20 - rot) & 0x1f);
9333         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9334       }
9335       break;
9336
9337     case M_ROL_I:
9338       {
9339         unsigned int rot;
9340
9341         if (imm_expr.X_op != O_constant)
9342           as_bad (_("Improper rotate count"));
9343         rot = imm_expr.X_add_number & 0x1f;
9344         if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
9345           {
9346             macro_build (NULL, "ror", SHFT_FMT, dreg, sreg, (32 - rot) & 0x1f);
9347             break;
9348           }
9349         if (rot == 0)
9350           {
9351             macro_build (NULL, "srl", SHFT_FMT, dreg, sreg, 0);
9352             break;
9353           }
9354         used_at = 1;
9355         macro_build (NULL, "sll", SHFT_FMT, AT, sreg, rot);
9356         macro_build (NULL, "srl", SHFT_FMT, dreg, sreg, (0x20 - rot) & 0x1f);
9357         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9358       }
9359       break;
9360
9361     case M_DROR:
9362       if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
9363         {
9364           macro_build (NULL, "drorv", "d,t,s", dreg, sreg, treg);
9365           break;
9366         }
9367       used_at = 1;
9368       macro_build (NULL, "dsubu", "d,v,t", AT, ZERO, treg);
9369       macro_build (NULL, "dsllv", "d,t,s", AT, sreg, AT);
9370       macro_build (NULL, "dsrlv", "d,t,s", dreg, sreg, treg);
9371       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9372       break;
9373
9374     case M_ROR:
9375       if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
9376         {
9377           macro_build (NULL, "rorv", "d,t,s", dreg, sreg, treg);
9378           break;
9379         }
9380       used_at = 1;
9381       macro_build (NULL, "subu", "d,v,t", AT, ZERO, treg);
9382       macro_build (NULL, "sllv", "d,t,s", AT, sreg, AT);
9383       macro_build (NULL, "srlv", "d,t,s", dreg, sreg, treg);
9384       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9385       break;
9386
9387     case M_DROR_I:
9388       {
9389         unsigned int rot;
9390         char *l;
9391         char *rr;
9392
9393         if (imm_expr.X_op != O_constant)
9394           as_bad (_("Improper rotate count"));
9395         rot = imm_expr.X_add_number & 0x3f;
9396         if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
9397           {
9398             if (rot >= 32)
9399               macro_build (NULL, "dror32", SHFT_FMT, dreg, sreg, rot - 32);
9400             else
9401               macro_build (NULL, "dror", SHFT_FMT, dreg, sreg, rot);
9402             break;
9403           }
9404         if (rot == 0)
9405           {
9406             macro_build (NULL, "dsrl", SHFT_FMT, dreg, sreg, 0);
9407             break;
9408           }
9409         rr = (rot < 0x20) ? "dsrl" : "dsrl32";
9410         l = ((0x40 - rot) < 0x20) ? "dsll" : "dsll32";
9411         rot &= 0x1f;
9412         used_at = 1;
9413         macro_build (NULL, rr, SHFT_FMT, AT, sreg, rot);
9414         macro_build (NULL, l, SHFT_FMT, dreg, sreg, (0x20 - rot) & 0x1f);
9415         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9416       }
9417       break;
9418
9419     case M_ROR_I:
9420       {
9421         unsigned int rot;
9422
9423         if (imm_expr.X_op != O_constant)
9424           as_bad (_("Improper rotate count"));
9425         rot = imm_expr.X_add_number & 0x1f;
9426         if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
9427           {
9428             macro_build (NULL, "ror", SHFT_FMT, dreg, sreg, rot);
9429             break;
9430           }
9431         if (rot == 0)
9432           {
9433             macro_build (NULL, "srl", SHFT_FMT, dreg, sreg, 0);
9434             break;
9435           }
9436         used_at = 1;
9437         macro_build (NULL, "srl", SHFT_FMT, AT, sreg, rot);
9438         macro_build (NULL, "sll", SHFT_FMT, dreg, sreg, (0x20 - rot) & 0x1f);
9439         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
9440       }
9441       break;
9442
9443     case M_SEQ:
9444       if (sreg == 0)
9445         macro_build (&expr1, "sltiu", "t,r,j", dreg, treg, BFD_RELOC_LO16);
9446       else if (treg == 0)
9447         macro_build (&expr1, "sltiu", "t,r,j", dreg, sreg, BFD_RELOC_LO16);
9448       else
9449         {
9450           macro_build (NULL, "xor", "d,v,t", dreg, sreg, treg);
9451           macro_build (&expr1, "sltiu", "t,r,j", dreg, dreg, BFD_RELOC_LO16);
9452         }
9453       break;
9454
9455     case M_SEQ_I:
9456       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
9457         {
9458           macro_build (&expr1, "sltiu", "t,r,j", dreg, sreg, BFD_RELOC_LO16);
9459           break;
9460         }
9461       if (sreg == 0)
9462         {
9463           as_warn (_("Instruction %s: result is always false"),
9464                    ip->insn_mo->name);
9465           move_register (dreg, 0);
9466           break;
9467         }
9468       if (CPU_HAS_SEQ (mips_opts.arch)
9469           && -512 <= imm_expr.X_add_number
9470           && imm_expr.X_add_number < 512)
9471         {
9472           macro_build (NULL, "seqi", "t,r,+Q", dreg, sreg,
9473                        (int) imm_expr.X_add_number);
9474           break;
9475         }
9476       if (imm_expr.X_op == O_constant
9477           && imm_expr.X_add_number >= 0
9478           && imm_expr.X_add_number < 0x10000)
9479         {
9480           macro_build (&imm_expr, "xori", "t,r,i", dreg, sreg, BFD_RELOC_LO16);
9481         }
9482       else if (imm_expr.X_op == O_constant
9483                && imm_expr.X_add_number > -0x8000
9484                && imm_expr.X_add_number < 0)
9485         {
9486           imm_expr.X_add_number = -imm_expr.X_add_number;
9487           macro_build (&imm_expr, HAVE_32BIT_GPRS ? "addiu" : "daddiu",
9488                        "t,r,j", dreg, sreg, BFD_RELOC_LO16);
9489         }
9490       else if (CPU_HAS_SEQ (mips_opts.arch))
9491         {
9492           used_at = 1;
9493           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9494           macro_build (NULL, "seq", "d,v,t", dreg, sreg, AT);
9495           break;
9496         }
9497       else
9498         {
9499           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9500           macro_build (NULL, "xor", "d,v,t", dreg, sreg, AT);
9501           used_at = 1;
9502         }
9503       macro_build (&expr1, "sltiu", "t,r,j", dreg, dreg, BFD_RELOC_LO16);
9504       break;
9505
9506     case M_SGE:         /* sreg >= treg <==> not (sreg < treg) */
9507       s = "slt";
9508       goto sge;
9509     case M_SGEU:
9510       s = "sltu";
9511     sge:
9512       macro_build (NULL, s, "d,v,t", dreg, sreg, treg);
9513       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
9514       break;
9515
9516     case M_SGE_I:               /* sreg >= I <==> not (sreg < I) */
9517     case M_SGEU_I:
9518       if (imm_expr.X_op == O_constant
9519           && imm_expr.X_add_number >= -0x8000
9520           && imm_expr.X_add_number < 0x8000)
9521         {
9522           macro_build (&imm_expr, mask == M_SGE_I ? "slti" : "sltiu", "t,r,j",
9523                        dreg, sreg, BFD_RELOC_LO16);
9524         }
9525       else
9526         {
9527           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9528           macro_build (NULL, mask == M_SGE_I ? "slt" : "sltu", "d,v,t",
9529                        dreg, sreg, AT);
9530           used_at = 1;
9531         }
9532       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
9533       break;
9534
9535     case M_SGT:         /* sreg > treg  <==>  treg < sreg */
9536       s = "slt";
9537       goto sgt;
9538     case M_SGTU:
9539       s = "sltu";
9540     sgt:
9541       macro_build (NULL, s, "d,v,t", dreg, treg, sreg);
9542       break;
9543
9544     case M_SGT_I:               /* sreg > I  <==>  I < sreg */
9545       s = "slt";
9546       goto sgti;
9547     case M_SGTU_I:
9548       s = "sltu";
9549     sgti:
9550       used_at = 1;
9551       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9552       macro_build (NULL, s, "d,v,t", dreg, AT, sreg);
9553       break;
9554
9555     case M_SLE: /* sreg <= treg  <==>  treg >= sreg  <==>  not (treg < sreg) */
9556       s = "slt";
9557       goto sle;
9558     case M_SLEU:
9559       s = "sltu";
9560     sle:
9561       macro_build (NULL, s, "d,v,t", dreg, treg, sreg);
9562       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
9563       break;
9564
9565     case M_SLE_I:       /* sreg <= I <==> I >= sreg <==> not (I < sreg) */
9566       s = "slt";
9567       goto slei;
9568     case M_SLEU_I:
9569       s = "sltu";
9570     slei:
9571       used_at = 1;
9572       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9573       macro_build (NULL, s, "d,v,t", dreg, AT, sreg);
9574       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
9575       break;
9576
9577     case M_SLT_I:
9578       if (imm_expr.X_op == O_constant
9579           && imm_expr.X_add_number >= -0x8000
9580           && imm_expr.X_add_number < 0x8000)
9581         {
9582           macro_build (&imm_expr, "slti", "t,r,j", dreg, sreg, BFD_RELOC_LO16);
9583           break;
9584         }
9585       used_at = 1;
9586       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9587       macro_build (NULL, "slt", "d,v,t", dreg, sreg, AT);
9588       break;
9589
9590     case M_SLTU_I:
9591       if (imm_expr.X_op == O_constant
9592           && imm_expr.X_add_number >= -0x8000
9593           && imm_expr.X_add_number < 0x8000)
9594         {
9595           macro_build (&imm_expr, "sltiu", "t,r,j", dreg, sreg,
9596                        BFD_RELOC_LO16);
9597           break;
9598         }
9599       used_at = 1;
9600       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9601       macro_build (NULL, "sltu", "d,v,t", dreg, sreg, AT);
9602       break;
9603
9604     case M_SNE:
9605       if (sreg == 0)
9606         macro_build (NULL, "sltu", "d,v,t", dreg, 0, treg);
9607       else if (treg == 0)
9608         macro_build (NULL, "sltu", "d,v,t", dreg, 0, sreg);
9609       else
9610         {
9611           macro_build (NULL, "xor", "d,v,t", dreg, sreg, treg);
9612           macro_build (NULL, "sltu", "d,v,t", dreg, 0, dreg);
9613         }
9614       break;
9615
9616     case M_SNE_I:
9617       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
9618         {
9619           macro_build (NULL, "sltu", "d,v,t", dreg, 0, sreg);
9620           break;
9621         }
9622       if (sreg == 0)
9623         {
9624           as_warn (_("Instruction %s: result is always true"),
9625                    ip->insn_mo->name);
9626           macro_build (&expr1, HAVE_32BIT_GPRS ? "addiu" : "daddiu", "t,r,j",
9627                        dreg, 0, BFD_RELOC_LO16);
9628           break;
9629         }
9630       if (CPU_HAS_SEQ (mips_opts.arch)
9631           && -512 <= imm_expr.X_add_number
9632           && imm_expr.X_add_number < 512)
9633         {
9634           macro_build (NULL, "snei", "t,r,+Q", dreg, sreg,
9635                        (int) imm_expr.X_add_number);
9636           break;
9637         }
9638       if (imm_expr.X_op == O_constant
9639           && imm_expr.X_add_number >= 0
9640           && imm_expr.X_add_number < 0x10000)
9641         {
9642           macro_build (&imm_expr, "xori", "t,r,i", dreg, sreg, BFD_RELOC_LO16);
9643         }
9644       else if (imm_expr.X_op == O_constant
9645                && imm_expr.X_add_number > -0x8000
9646                && imm_expr.X_add_number < 0)
9647         {
9648           imm_expr.X_add_number = -imm_expr.X_add_number;
9649           macro_build (&imm_expr, HAVE_32BIT_GPRS ? "addiu" : "daddiu",
9650                        "t,r,j", dreg, sreg, BFD_RELOC_LO16);
9651         }
9652       else if (CPU_HAS_SEQ (mips_opts.arch))
9653         {
9654           used_at = 1;
9655           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9656           macro_build (NULL, "sne", "d,v,t", dreg, sreg, AT);
9657           break;
9658         }
9659       else
9660         {
9661           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9662           macro_build (NULL, "xor", "d,v,t", dreg, sreg, AT);
9663           used_at = 1;
9664         }
9665       macro_build (NULL, "sltu", "d,v,t", dreg, 0, dreg);
9666       break;
9667
9668     case M_SUB_I:
9669       s = "addi";
9670       s2 = "sub";
9671       goto do_subi;
9672     case M_SUBU_I:
9673       s = "addiu";
9674       s2 = "subu";
9675       goto do_subi;
9676     case M_DSUB_I:
9677       dbl = 1;
9678       s = "daddi";
9679       s2 = "dsub";
9680       if (!mips_opts.micromips)
9681         goto do_subi;
9682       if (imm_expr.X_op == O_constant
9683           && imm_expr.X_add_number > -0x200
9684           && imm_expr.X_add_number <= 0x200)
9685         {
9686           macro_build (NULL, s, "t,r,.", dreg, sreg, -imm_expr.X_add_number);
9687           break;
9688         }
9689       goto do_subi_i;
9690     case M_DSUBU_I:
9691       dbl = 1;
9692       s = "daddiu";
9693       s2 = "dsubu";
9694     do_subi:
9695       if (imm_expr.X_op == O_constant
9696           && imm_expr.X_add_number > -0x8000
9697           && imm_expr.X_add_number <= 0x8000)
9698         {
9699           imm_expr.X_add_number = -imm_expr.X_add_number;
9700           macro_build (&imm_expr, s, "t,r,j", dreg, sreg, BFD_RELOC_LO16);
9701           break;
9702         }
9703     do_subi_i:
9704       used_at = 1;
9705       load_register (AT, &imm_expr, dbl);
9706       macro_build (NULL, s2, "d,v,t", dreg, sreg, AT);
9707       break;
9708
9709     case M_TEQ_I:
9710       s = "teq";
9711       goto trap;
9712     case M_TGE_I:
9713       s = "tge";
9714       goto trap;
9715     case M_TGEU_I:
9716       s = "tgeu";
9717       goto trap;
9718     case M_TLT_I:
9719       s = "tlt";
9720       goto trap;
9721     case M_TLTU_I:
9722       s = "tltu";
9723       goto trap;
9724     case M_TNE_I:
9725       s = "tne";
9726     trap:
9727       used_at = 1;
9728       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
9729       macro_build (NULL, s, "s,t", sreg, AT);
9730       break;
9731
9732     case M_TRUNCWS:
9733     case M_TRUNCWD:
9734       gas_assert (!mips_opts.micromips);
9735       gas_assert (mips_opts.isa == ISA_MIPS1);
9736       used_at = 1;
9737       sreg = (ip->insn_opcode >> 11) & 0x1f;    /* floating reg */
9738       dreg = (ip->insn_opcode >> 06) & 0x1f;    /* floating reg */
9739
9740       /*
9741        * Is the double cfc1 instruction a bug in the mips assembler;
9742        * or is there a reason for it?
9743        */
9744       start_noreorder ();
9745       macro_build (NULL, "cfc1", "t,G", treg, RA);
9746       macro_build (NULL, "cfc1", "t,G", treg, RA);
9747       macro_build (NULL, "nop", "");
9748       expr1.X_add_number = 3;
9749       macro_build (&expr1, "ori", "t,r,i", AT, treg, BFD_RELOC_LO16);
9750       expr1.X_add_number = 2;
9751       macro_build (&expr1, "xori", "t,r,i", AT, AT, BFD_RELOC_LO16);
9752       macro_build (NULL, "ctc1", "t,G", AT, RA);
9753       macro_build (NULL, "nop", "");
9754       macro_build (NULL, mask == M_TRUNCWD ? "cvt.w.d" : "cvt.w.s", "D,S",
9755                    dreg, sreg);
9756       macro_build (NULL, "ctc1", "t,G", treg, RA);
9757       macro_build (NULL, "nop", "");
9758       end_noreorder ();
9759       break;
9760
9761     case M_ULH_A:
9762       ab = 1;
9763     case M_ULH:
9764       s = "lb";
9765       s2 = "lbu";
9766       off = 1;
9767       goto uld_st;
9768     case M_ULHU_A:
9769       ab = 1;
9770     case M_ULHU:
9771       s = "lbu";
9772       s2 = "lbu";
9773       off = 1;
9774       goto uld_st;
9775     case M_ULW_A:
9776       ab = 1;
9777     case M_ULW:
9778       s = "lwl";
9779       s2 = "lwr";
9780       off12 = mips_opts.micromips;
9781       off = 3;
9782       goto uld_st;
9783     case M_ULD_A:
9784       ab = 1;
9785     case M_ULD:
9786       s = "ldl";
9787       s2 = "ldr";
9788       off12 = mips_opts.micromips;
9789       off = 7;
9790       goto uld_st;
9791     case M_USH_A:
9792       ab = 1;
9793     case M_USH:
9794       s = "sb";
9795       s2 = "sb";
9796       off = 1;
9797       ust = 1;
9798       goto uld_st;
9799     case M_USW_A:
9800       ab = 1;
9801     case M_USW:
9802       s = "swl";
9803       s2 = "swr";
9804       off12 = mips_opts.micromips;
9805       off = 3;
9806       ust = 1;
9807       goto uld_st;
9808     case M_USD_A:
9809       ab = 1;
9810     case M_USD:
9811       s = "sdl";
9812       s2 = "sdr";
9813       off12 = mips_opts.micromips;
9814       off = 7;
9815       ust = 1;
9816
9817     uld_st:
9818       if (!ab && offset_expr.X_add_number >= 0x8000 - off)
9819         as_bad (_("Operand overflow"));
9820
9821       ep = &offset_expr;
9822       expr1.X_add_number = 0;
9823       if (ab)
9824         {
9825           used_at = 1;
9826           tempreg = AT;
9827           load_address (tempreg, ep, &used_at);
9828           if (breg != 0)
9829             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
9830                          tempreg, tempreg, breg);
9831           breg = tempreg;
9832           tempreg = treg;
9833           ep = &expr1;
9834         }
9835       else if (off12
9836                && (offset_expr.X_op != O_constant
9837                    || !IS_SEXT_12BIT_NUM (offset_expr.X_add_number)
9838                    || !IS_SEXT_12BIT_NUM (offset_expr.X_add_number + off)))
9839         {
9840           used_at = 1;
9841           tempreg = AT;
9842           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", tempreg, breg,
9843                        -1, offset_reloc[0], offset_reloc[1], offset_reloc[2]);
9844           breg = tempreg;
9845           tempreg = treg;
9846           ep = &expr1;
9847         }
9848       else if (!ust && treg == breg)
9849         {
9850           used_at = 1;
9851           tempreg = AT;
9852         }
9853       else
9854         tempreg = treg;
9855
9856       if (off == 1)
9857         goto ulh_sh;
9858
9859       if (!target_big_endian)
9860         ep->X_add_number += off;
9861       if (!off12)
9862         macro_build (ep, s, "t,o(b)", tempreg, BFD_RELOC_LO16, breg);
9863       else
9864         macro_build (NULL, s, "t,~(b)",
9865                      tempreg, (unsigned long) ep->X_add_number, breg);
9866
9867       if (!target_big_endian)
9868         ep->X_add_number -= off;
9869       else
9870         ep->X_add_number += off;
9871       if (!off12)
9872         macro_build (ep, s2, "t,o(b)", tempreg, BFD_RELOC_LO16, breg);
9873       else
9874         macro_build (NULL, s2, "t,~(b)",
9875                      tempreg, (unsigned long) ep->X_add_number, breg);
9876
9877       /* If necessary, move the result in tempreg to the final destination.  */
9878       if (!ust && treg != tempreg)
9879         {
9880           /* Protect second load's delay slot.  */
9881           load_delay_nop ();
9882           move_register (treg, tempreg);
9883         }
9884       break;
9885
9886     ulh_sh:
9887       used_at = 1;
9888       if (target_big_endian == ust)
9889         ep->X_add_number += off;
9890       tempreg = ust || ab ? treg : AT;
9891       macro_build (ep, s, "t,o(b)", tempreg, BFD_RELOC_LO16, breg);
9892
9893       /* For halfword transfers we need a temporary register to shuffle
9894          bytes.  Unfortunately for M_USH_A we have none available before
9895          the next store as AT holds the base address.  We deal with this
9896          case by clobbering TREG and then restoring it as with ULH.  */
9897       tempreg = ust == ab ? treg : AT;
9898       if (ust)
9899         macro_build (NULL, "srl", SHFT_FMT, tempreg, treg, 8);
9900
9901       if (target_big_endian == ust)
9902         ep->X_add_number -= off;
9903       else
9904         ep->X_add_number += off;
9905       macro_build (ep, s2, "t,o(b)", tempreg, BFD_RELOC_LO16, breg);
9906
9907       /* For M_USH_A re-retrieve the LSB.  */
9908       if (ust && ab)
9909         {
9910           if (target_big_endian)
9911             ep->X_add_number += off;
9912           else
9913             ep->X_add_number -= off;
9914           macro_build (&expr1, "lbu", "t,o(b)", AT, BFD_RELOC_LO16, AT);
9915         }
9916       /* For ULH and M_USH_A OR the LSB in.  */
9917       if (!ust || ab)
9918         {
9919           tempreg = !ab ? AT : treg;
9920           macro_build (NULL, "sll", SHFT_FMT, tempreg, tempreg, 8);
9921           macro_build (NULL, "or", "d,v,t", treg, treg, AT);
9922         }
9923       break;
9924
9925     default:
9926       /* FIXME: Check if this is one of the itbl macros, since they
9927          are added dynamically.  */
9928       as_bad (_("Macro %s not implemented yet"), ip->insn_mo->name);
9929       break;
9930     }
9931   if (!mips_opts.at && used_at)
9932     as_bad (_("Macro used $at after \".set noat\""));
9933 }
9934
9935 /* Implement macros in mips16 mode.  */
9936
9937 static void
9938 mips16_macro (struct mips_cl_insn *ip)
9939 {
9940   int mask;
9941   int xreg, yreg, zreg, tmp;
9942   expressionS expr1;
9943   int dbl;
9944   const char *s, *s2, *s3;
9945
9946   mask = ip->insn_mo->mask;
9947
9948   xreg = MIPS16_EXTRACT_OPERAND (RX, *ip);
9949   yreg = MIPS16_EXTRACT_OPERAND (RY, *ip);
9950   zreg = MIPS16_EXTRACT_OPERAND (RZ, *ip);
9951
9952   expr1.X_op = O_constant;
9953   expr1.X_op_symbol = NULL;
9954   expr1.X_add_symbol = NULL;
9955   expr1.X_add_number = 1;
9956
9957   dbl = 0;
9958
9959   switch (mask)
9960     {
9961     default:
9962       internalError ();
9963
9964     case M_DDIV_3:
9965       dbl = 1;
9966     case M_DIV_3:
9967       s = "mflo";
9968       goto do_div3;
9969     case M_DREM_3:
9970       dbl = 1;
9971     case M_REM_3:
9972       s = "mfhi";
9973     do_div3:
9974       start_noreorder ();
9975       macro_build (NULL, dbl ? "ddiv" : "div", "0,x,y", xreg, yreg);
9976       expr1.X_add_number = 2;
9977       macro_build (&expr1, "bnez", "x,p", yreg);
9978       macro_build (NULL, "break", "6", 7);
9979
9980       /* FIXME: The normal code checks for of -1 / -0x80000000 here,
9981          since that causes an overflow.  We should do that as well,
9982          but I don't see how to do the comparisons without a temporary
9983          register.  */
9984       end_noreorder ();
9985       macro_build (NULL, s, "x", zreg);
9986       break;
9987
9988     case M_DIVU_3:
9989       s = "divu";
9990       s2 = "mflo";
9991       goto do_divu3;
9992     case M_REMU_3:
9993       s = "divu";
9994       s2 = "mfhi";
9995       goto do_divu3;
9996     case M_DDIVU_3:
9997       s = "ddivu";
9998       s2 = "mflo";
9999       goto do_divu3;
10000     case M_DREMU_3:
10001       s = "ddivu";
10002       s2 = "mfhi";
10003     do_divu3:
10004       start_noreorder ();
10005       macro_build (NULL, s, "0,x,y", xreg, yreg);
10006       expr1.X_add_number = 2;
10007       macro_build (&expr1, "bnez", "x,p", yreg);
10008       macro_build (NULL, "break", "6", 7);
10009       end_noreorder ();
10010       macro_build (NULL, s2, "x", zreg);
10011       break;
10012
10013     case M_DMUL:
10014       dbl = 1;
10015     case M_MUL:
10016       macro_build (NULL, dbl ? "dmultu" : "multu", "x,y", xreg, yreg);
10017       macro_build (NULL, "mflo", "x", zreg);
10018       break;
10019
10020     case M_DSUBU_I:
10021       dbl = 1;
10022       goto do_subu;
10023     case M_SUBU_I:
10024     do_subu:
10025       if (imm_expr.X_op != O_constant)
10026         as_bad (_("Unsupported large constant"));
10027       imm_expr.X_add_number = -imm_expr.X_add_number;
10028       macro_build (&imm_expr, dbl ? "daddiu" : "addiu", "y,x,4", yreg, xreg);
10029       break;
10030
10031     case M_SUBU_I_2:
10032       if (imm_expr.X_op != O_constant)
10033         as_bad (_("Unsupported large constant"));
10034       imm_expr.X_add_number = -imm_expr.X_add_number;
10035       macro_build (&imm_expr, "addiu", "x,k", xreg);
10036       break;
10037
10038     case M_DSUBU_I_2:
10039       if (imm_expr.X_op != O_constant)
10040         as_bad (_("Unsupported large constant"));
10041       imm_expr.X_add_number = -imm_expr.X_add_number;
10042       macro_build (&imm_expr, "daddiu", "y,j", yreg);
10043       break;
10044
10045     case M_BEQ:
10046       s = "cmp";
10047       s2 = "bteqz";
10048       goto do_branch;
10049     case M_BNE:
10050       s = "cmp";
10051       s2 = "btnez";
10052       goto do_branch;
10053     case M_BLT:
10054       s = "slt";
10055       s2 = "btnez";
10056       goto do_branch;
10057     case M_BLTU:
10058       s = "sltu";
10059       s2 = "btnez";
10060       goto do_branch;
10061     case M_BLE:
10062       s = "slt";
10063       s2 = "bteqz";
10064       goto do_reverse_branch;
10065     case M_BLEU:
10066       s = "sltu";
10067       s2 = "bteqz";
10068       goto do_reverse_branch;
10069     case M_BGE:
10070       s = "slt";
10071       s2 = "bteqz";
10072       goto do_branch;
10073     case M_BGEU:
10074       s = "sltu";
10075       s2 = "bteqz";
10076       goto do_branch;
10077     case M_BGT:
10078       s = "slt";
10079       s2 = "btnez";
10080       goto do_reverse_branch;
10081     case M_BGTU:
10082       s = "sltu";
10083       s2 = "btnez";
10084
10085     do_reverse_branch:
10086       tmp = xreg;
10087       xreg = yreg;
10088       yreg = tmp;
10089
10090     do_branch:
10091       macro_build (NULL, s, "x,y", xreg, yreg);
10092       macro_build (&offset_expr, s2, "p");
10093       break;
10094
10095     case M_BEQ_I:
10096       s = "cmpi";
10097       s2 = "bteqz";
10098       s3 = "x,U";
10099       goto do_branch_i;
10100     case M_BNE_I:
10101       s = "cmpi";
10102       s2 = "btnez";
10103       s3 = "x,U";
10104       goto do_branch_i;
10105     case M_BLT_I:
10106       s = "slti";
10107       s2 = "btnez";
10108       s3 = "x,8";
10109       goto do_branch_i;
10110     case M_BLTU_I:
10111       s = "sltiu";
10112       s2 = "btnez";
10113       s3 = "x,8";
10114       goto do_branch_i;
10115     case M_BLE_I:
10116       s = "slti";
10117       s2 = "btnez";
10118       s3 = "x,8";
10119       goto do_addone_branch_i;
10120     case M_BLEU_I:
10121       s = "sltiu";
10122       s2 = "btnez";
10123       s3 = "x,8";
10124       goto do_addone_branch_i;
10125     case M_BGE_I:
10126       s = "slti";
10127       s2 = "bteqz";
10128       s3 = "x,8";
10129       goto do_branch_i;
10130     case M_BGEU_I:
10131       s = "sltiu";
10132       s2 = "bteqz";
10133       s3 = "x,8";
10134       goto do_branch_i;
10135     case M_BGT_I:
10136       s = "slti";
10137       s2 = "bteqz";
10138       s3 = "x,8";
10139       goto do_addone_branch_i;
10140     case M_BGTU_I:
10141       s = "sltiu";
10142       s2 = "bteqz";
10143       s3 = "x,8";
10144
10145     do_addone_branch_i:
10146       if (imm_expr.X_op != O_constant)
10147         as_bad (_("Unsupported large constant"));
10148       ++imm_expr.X_add_number;
10149
10150     do_branch_i:
10151       macro_build (&imm_expr, s, s3, xreg);
10152       macro_build (&offset_expr, s2, "p");
10153       break;
10154
10155     case M_ABS:
10156       expr1.X_add_number = 0;
10157       macro_build (&expr1, "slti", "x,8", yreg);
10158       if (xreg != yreg)
10159         move_register (xreg, yreg);
10160       expr1.X_add_number = 2;
10161       macro_build (&expr1, "bteqz", "p");
10162       macro_build (NULL, "neg", "x,w", xreg, xreg);
10163     }
10164 }
10165
10166 /* For consistency checking, verify that all bits are specified either
10167    by the match/mask part of the instruction definition, or by the
10168    operand list.  */
10169 static int
10170 validate_mips_insn (const struct mips_opcode *opc)
10171 {
10172   const char *p = opc->args;
10173   char c;
10174   unsigned long used_bits = opc->mask;
10175
10176   if ((used_bits & opc->match) != opc->match)
10177     {
10178       as_bad (_("internal: bad mips opcode (mask error): %s %s"),
10179               opc->name, opc->args);
10180       return 0;
10181     }
10182 #define USE_BITS(mask,shift)    (used_bits |= ((mask) << (shift)))
10183   while (*p)
10184     switch (c = *p++)
10185       {
10186       case ',': break;
10187       case '(': break;
10188       case ')': break;
10189       case '+':
10190         switch (c = *p++)
10191           {
10192           case '1': USE_BITS (OP_MASK_UDI1,     OP_SH_UDI1);    break;
10193           case '2': USE_BITS (OP_MASK_UDI2,     OP_SH_UDI2);    break;
10194           case '3': USE_BITS (OP_MASK_UDI3,     OP_SH_UDI3);    break;
10195           case '4': USE_BITS (OP_MASK_UDI4,     OP_SH_UDI4);    break;
10196           case 'A': USE_BITS (OP_MASK_SHAMT,    OP_SH_SHAMT);   break;
10197           case 'B': USE_BITS (OP_MASK_INSMSB,   OP_SH_INSMSB);  break;
10198           case 'C': USE_BITS (OP_MASK_EXTMSBD,  OP_SH_EXTMSBD); break;
10199           case 'D': USE_BITS (OP_MASK_RD,       OP_SH_RD);
10200                     USE_BITS (OP_MASK_SEL,      OP_SH_SEL);     break;
10201           case 'E': USE_BITS (OP_MASK_SHAMT,    OP_SH_SHAMT);   break;
10202           case 'F': USE_BITS (OP_MASK_INSMSB,   OP_SH_INSMSB);  break;
10203           case 'G': USE_BITS (OP_MASK_EXTMSBD,  OP_SH_EXTMSBD); break;
10204           case 'H': USE_BITS (OP_MASK_EXTMSBD,  OP_SH_EXTMSBD); break;
10205           case 'I': break;
10206           case 't': USE_BITS (OP_MASK_RT,       OP_SH_RT);      break;
10207           case 'T': USE_BITS (OP_MASK_RT,       OP_SH_RT);
10208                     USE_BITS (OP_MASK_SEL,      OP_SH_SEL);     break;
10209           case 'x': USE_BITS (OP_MASK_BBITIND,  OP_SH_BBITIND); break;
10210           case 'X': USE_BITS (OP_MASK_BBITIND,  OP_SH_BBITIND); break;
10211           case 'p': USE_BITS (OP_MASK_CINSPOS,  OP_SH_CINSPOS); break;
10212           case 'P': USE_BITS (OP_MASK_CINSPOS,  OP_SH_CINSPOS); break;
10213           case 'Q': USE_BITS (OP_MASK_SEQI,     OP_SH_SEQI);    break;
10214           case 's': USE_BITS (OP_MASK_CINSLM1,  OP_SH_CINSLM1); break;
10215           case 'S': USE_BITS (OP_MASK_CINSLM1,  OP_SH_CINSLM1); break;
10216           case 'z': USE_BITS (OP_MASK_RZ,       OP_SH_RZ);      break;
10217           case 'Z': USE_BITS (OP_MASK_FZ,       OP_SH_FZ);      break;
10218           case 'a': USE_BITS (OP_MASK_OFFSET_A, OP_SH_OFFSET_A); break;
10219           case 'b': USE_BITS (OP_MASK_OFFSET_B, OP_SH_OFFSET_B); break;
10220           case 'c': USE_BITS (OP_MASK_OFFSET_C, OP_SH_OFFSET_C); break;
10221
10222           default:
10223             as_bad (_("internal: bad mips opcode (unknown extension operand type `+%c'): %s %s"),
10224                     c, opc->name, opc->args);
10225             return 0;
10226           }
10227         break;
10228       case '<': USE_BITS (OP_MASK_SHAMT,        OP_SH_SHAMT);   break;
10229       case '>': USE_BITS (OP_MASK_SHAMT,        OP_SH_SHAMT);   break;
10230       case 'A': break;
10231       case 'B': USE_BITS (OP_MASK_CODE20,       OP_SH_CODE20);  break;
10232       case 'C': USE_BITS (OP_MASK_COPZ,         OP_SH_COPZ);    break;
10233       case 'D': USE_BITS (OP_MASK_FD,           OP_SH_FD);      break;
10234       case 'E': USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
10235       case 'F': break;
10236       case 'G': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
10237       case 'H': USE_BITS (OP_MASK_SEL,          OP_SH_SEL);     break;
10238       case 'I': break;
10239       case 'J': USE_BITS (OP_MASK_CODE19,       OP_SH_CODE19);  break;
10240       case 'K': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
10241       case 'L': break;
10242       case 'M': USE_BITS (OP_MASK_CCC,          OP_SH_CCC);     break;
10243       case 'N': USE_BITS (OP_MASK_BCC,          OP_SH_BCC);     break;
10244       case 'O': USE_BITS (OP_MASK_ALN,          OP_SH_ALN);     break;
10245       case 'Q': USE_BITS (OP_MASK_VSEL,         OP_SH_VSEL);
10246                 USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
10247       case 'R': USE_BITS (OP_MASK_FR,           OP_SH_FR);      break;
10248       case 'S': USE_BITS (OP_MASK_FS,           OP_SH_FS);      break;
10249       case 'T': USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
10250       case 'V': USE_BITS (OP_MASK_FS,           OP_SH_FS);      break;
10251       case 'W': USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
10252       case 'X': USE_BITS (OP_MASK_FD,           OP_SH_FD);      break;
10253       case 'Y': USE_BITS (OP_MASK_FS,           OP_SH_FS);      break;
10254       case 'Z': USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
10255       case 'a': USE_BITS (OP_MASK_TARGET,       OP_SH_TARGET);  break;
10256       case 'b': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
10257       case 'c': USE_BITS (OP_MASK_CODE,         OP_SH_CODE);    break;
10258       case 'd': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
10259       case 'f': break;
10260       case 'h': USE_BITS (OP_MASK_PREFX,        OP_SH_PREFX);   break;
10261       case 'i': USE_BITS (OP_MASK_IMMEDIATE,    OP_SH_IMMEDIATE); break;
10262       case 'j': USE_BITS (OP_MASK_DELTA,        OP_SH_DELTA);   break;
10263       case 'k': USE_BITS (OP_MASK_CACHE,        OP_SH_CACHE);   break;
10264       case 'l': break;
10265       case 'o': USE_BITS (OP_MASK_DELTA,        OP_SH_DELTA);   break;
10266       case 'p': USE_BITS (OP_MASK_DELTA,        OP_SH_DELTA);   break;
10267       case 'q': USE_BITS (OP_MASK_CODE2,        OP_SH_CODE2);   break;
10268       case 'r': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
10269       case 's': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
10270       case 't': USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
10271       case 'u': USE_BITS (OP_MASK_IMMEDIATE,    OP_SH_IMMEDIATE); break;
10272       case 'v': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
10273       case 'w': USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
10274       case 'x': break;
10275       case 'z': break;
10276       case 'P': USE_BITS (OP_MASK_PERFREG,      OP_SH_PERFREG); break;
10277       case 'U': USE_BITS (OP_MASK_RD,           OP_SH_RD);
10278                 USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
10279       case 'e': USE_BITS (OP_MASK_VECBYTE,      OP_SH_VECBYTE); break;
10280       case '%': USE_BITS (OP_MASK_VECALIGN,     OP_SH_VECALIGN); break;
10281       case '[': break;
10282       case ']': break;
10283       case '1': USE_BITS (OP_MASK_SHAMT,        OP_SH_SHAMT);   break;
10284       case '2': USE_BITS (OP_MASK_BP,           OP_SH_BP);      break;
10285       case '3': USE_BITS (OP_MASK_SA3,          OP_SH_SA3);     break;
10286       case '4': USE_BITS (OP_MASK_SA4,          OP_SH_SA4);     break;
10287       case '5': USE_BITS (OP_MASK_IMM8,         OP_SH_IMM8);    break;
10288       case '6': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
10289       case '7': USE_BITS (OP_MASK_DSPACC,       OP_SH_DSPACC);  break;
10290       case '8': USE_BITS (OP_MASK_WRDSP,        OP_SH_WRDSP);   break;
10291       case '9': USE_BITS (OP_MASK_DSPACC_S,     OP_SH_DSPACC_S);break;
10292       case '0': USE_BITS (OP_MASK_DSPSFT,       OP_SH_DSPSFT);  break;
10293       case '\'': USE_BITS (OP_MASK_RDDSP,       OP_SH_RDDSP);   break;
10294       case ':': USE_BITS (OP_MASK_DSPSFT_7,     OP_SH_DSPSFT_7);break;
10295       case '@': USE_BITS (OP_MASK_IMM10,        OP_SH_IMM10);   break;
10296       case '!': USE_BITS (OP_MASK_MT_U,         OP_SH_MT_U);    break;
10297       case '$': USE_BITS (OP_MASK_MT_H,         OP_SH_MT_H);    break;
10298       case '*': USE_BITS (OP_MASK_MTACC_T,      OP_SH_MTACC_T); break;
10299       case '&': USE_BITS (OP_MASK_MTACC_D,      OP_SH_MTACC_D); break;
10300       case '\\': USE_BITS (OP_MASK_3BITPOS,     OP_SH_3BITPOS); break;
10301       case '~': USE_BITS (OP_MASK_OFFSET12,     OP_SH_OFFSET12); break;
10302       case 'g': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
10303       default:
10304         as_bad (_("internal: bad mips opcode (unknown operand type `%c'): %s %s"),
10305                 c, opc->name, opc->args);
10306         return 0;
10307       }
10308 #undef USE_BITS
10309   if (used_bits != 0xffffffff)
10310     {
10311       as_bad (_("internal: bad mips opcode (bits 0x%lx undefined): %s %s"),
10312               ~used_bits & 0xffffffff, opc->name, opc->args);
10313       return 0;
10314     }
10315   return 1;
10316 }
10317
10318 /* For consistency checking, verify that the length implied matches the
10319    major opcode and that all bits are specified either by the match/mask
10320    part of the instruction definition, or by the operand list.  */
10321
10322 static int
10323 validate_micromips_insn (const struct mips_opcode *opc)
10324 {
10325   unsigned long match = opc->match;
10326   unsigned long mask = opc->mask;
10327   const char *p = opc->args;
10328   unsigned long insn_bits;
10329   unsigned long used_bits;
10330   unsigned long major;
10331   unsigned int length;
10332   char e;
10333   char c;
10334
10335   if ((mask & match) != match)
10336     {
10337       as_bad (_("Internal error: bad microMIPS opcode (mask error): %s %s"),
10338               opc->name, opc->args);
10339       return 0;
10340     }
10341   length = micromips_insn_length (opc);
10342   if (length != 2 && length != 4)
10343     {
10344       as_bad (_("Internal error: bad microMIPS opcode (incorrect length: %u): "
10345                 "%s %s"), length, opc->name, opc->args);
10346       return 0;
10347     }
10348   major = match >> (10 + 8 * (length - 2));
10349   if ((length == 2 && (major & 7) != 1 && (major & 6) != 2)
10350       || (length == 4 && (major & 7) != 0 && (major & 4) != 4))
10351     {
10352       as_bad (_("Internal error: bad microMIPS opcode "
10353                 "(opcode/length mismatch): %s %s"), opc->name, opc->args);
10354       return 0;
10355     }
10356
10357   /* Shift piecewise to avoid an overflow where unsigned long is 32-bit.  */
10358   insn_bits = 1 << 4 * length;
10359   insn_bits <<= 4 * length;
10360   insn_bits -= 1;
10361   used_bits = mask;
10362 #define USE_BITS(field) \
10363   (used_bits |= MICROMIPSOP_MASK_##field << MICROMIPSOP_SH_##field)
10364   while (*p)
10365     switch (c = *p++)
10366       {
10367       case ',': break;
10368       case '(': break;
10369       case ')': break;
10370       case '+':
10371         e = c;
10372         switch (c = *p++)
10373           {
10374           case 'A': USE_BITS (EXTLSB);  break;
10375           case 'B': USE_BITS (INSMSB);  break;
10376           case 'C': USE_BITS (EXTMSBD); break;
10377           case 'D': USE_BITS (RS);      USE_BITS (SEL); break;
10378           case 'E': USE_BITS (EXTLSB);  break;
10379           case 'F': USE_BITS (INSMSB);  break;
10380           case 'G': USE_BITS (EXTMSBD); break;
10381           case 'H': USE_BITS (EXTMSBD); break;
10382           default:
10383             as_bad (_("Internal error: bad mips opcode "
10384                       "(unknown extension operand type `%c%c'): %s %s"),
10385                     e, c, opc->name, opc->args);
10386             return 0;
10387           }
10388         break;
10389       case 'm':
10390         e = c;
10391         switch (c = *p++)
10392           {
10393           case 'A': USE_BITS (IMMA);    break;
10394           case 'B': USE_BITS (IMMB);    break;
10395           case 'C': USE_BITS (IMMC);    break;
10396           case 'D': USE_BITS (IMMD);    break;
10397           case 'E': USE_BITS (IMME);    break;
10398           case 'F': USE_BITS (IMMF);    break;
10399           case 'G': USE_BITS (IMMG);    break;
10400           case 'H': USE_BITS (IMMH);    break;
10401           case 'I': USE_BITS (IMMI);    break;
10402           case 'J': USE_BITS (IMMJ);    break;
10403           case 'L': USE_BITS (IMML);    break;
10404           case 'M': USE_BITS (IMMM);    break;
10405           case 'N': USE_BITS (IMMN);    break;
10406           case 'O': USE_BITS (IMMO);    break;
10407           case 'P': USE_BITS (IMMP);    break;
10408           case 'Q': USE_BITS (IMMQ);    break;
10409           case 'U': USE_BITS (IMMU);    break;
10410           case 'W': USE_BITS (IMMW);    break;
10411           case 'X': USE_BITS (IMMX);    break;
10412           case 'Y': USE_BITS (IMMY);    break;
10413           case 'Z': break;
10414           case 'a': break;
10415           case 'b': USE_BITS (MB);      break;
10416           case 'c': USE_BITS (MC);      break;
10417           case 'd': USE_BITS (MD);      break;
10418           case 'e': USE_BITS (ME);      break;
10419           case 'f': USE_BITS (MF);      break;
10420           case 'g': USE_BITS (MG);      break;
10421           case 'h': USE_BITS (MH);      break;
10422           case 'i': USE_BITS (MI);      break;
10423           case 'j': USE_BITS (MJ);      break;
10424           case 'l': USE_BITS (ML);      break;
10425           case 'm': USE_BITS (MM);      break;
10426           case 'n': USE_BITS (MN);      break;
10427           case 'p': USE_BITS (MP);      break;
10428           case 'q': USE_BITS (MQ);      break;
10429           case 'r': break;
10430           case 's': break;
10431           case 't': break;
10432           case 'x': break;
10433           case 'y': break;
10434           case 'z': break;
10435           default:
10436             as_bad (_("Internal error: bad mips opcode "
10437                       "(unknown extension operand type `%c%c'): %s %s"),
10438                     e, c, opc->name, opc->args);
10439             return 0;
10440           }
10441         break;
10442       case '.': USE_BITS (OFFSET10);    break;
10443       case '1': USE_BITS (STYPE);       break;
10444       case '<': USE_BITS (SHAMT);       break;
10445       case '>': USE_BITS (SHAMT);       break;
10446       case 'B': USE_BITS (CODE10);      break;
10447       case 'C': USE_BITS (COPZ);        break;
10448       case 'D': USE_BITS (FD);          break;
10449       case 'E': USE_BITS (RT);          break;
10450       case 'G': USE_BITS (RS);          break;
10451       case 'H': USE_BITS (SEL);         break;
10452       case 'K': USE_BITS (RS);          break;
10453       case 'M': USE_BITS (CCC);         break;
10454       case 'N': USE_BITS (BCC);         break;
10455       case 'R': USE_BITS (FR);          break;
10456       case 'S': USE_BITS (FS);          break;
10457       case 'T': USE_BITS (FT);          break;
10458       case 'V': USE_BITS (FS);          break;
10459       case '\\': USE_BITS (3BITPOS);    break;
10460       case 'a': USE_BITS (TARGET);      break;
10461       case 'b': USE_BITS (RS);          break;
10462       case 'c': USE_BITS (CODE);        break;
10463       case 'd': USE_BITS (RD);          break;
10464       case 'h': USE_BITS (PREFX);       break;
10465       case 'i': USE_BITS (IMMEDIATE);   break;
10466       case 'j': USE_BITS (DELTA);       break;
10467       case 'k': USE_BITS (CACHE);       break;
10468       case 'n': USE_BITS (RT);          break;
10469       case 'o': USE_BITS (DELTA);       break;
10470       case 'p': USE_BITS (DELTA);       break;
10471       case 'q': USE_BITS (CODE2);       break;
10472       case 'r': USE_BITS (RS);          break;
10473       case 's': USE_BITS (RS);          break;
10474       case 't': USE_BITS (RT);          break;
10475       case 'u': USE_BITS (IMMEDIATE);   break;
10476       case 'v': USE_BITS (RS);          break;
10477       case 'w': USE_BITS (RT);          break;
10478       case 'y': USE_BITS (RS3);         break;
10479       case 'z': break;
10480       case '|': USE_BITS (TRAP);        break;
10481       case '~': USE_BITS (OFFSET12);    break;
10482       default:
10483         as_bad (_("Internal error: bad microMIPS opcode "
10484                   "(unknown operand type `%c'): %s %s"),
10485                 c, opc->name, opc->args);
10486         return 0;
10487       }
10488 #undef USE_BITS
10489   if (used_bits != insn_bits)
10490     {
10491       if (~used_bits & insn_bits)
10492         as_bad (_("Internal error: bad microMIPS opcode "
10493                   "(bits 0x%lx undefined): %s %s"),
10494                 ~used_bits & insn_bits, opc->name, opc->args);
10495       if (used_bits & ~insn_bits)
10496         as_bad (_("Internal error: bad microMIPS opcode "
10497                   "(bits 0x%lx defined): %s %s"),
10498                 used_bits & ~insn_bits, opc->name, opc->args);
10499       return 0;
10500     }
10501   return 1;
10502 }
10503
10504 /* UDI immediates.  */
10505 struct mips_immed {
10506   char          type;
10507   unsigned int  shift;
10508   unsigned long mask;
10509   const char *  desc;
10510 };
10511
10512 static const struct mips_immed mips_immed[] = {
10513   { '1',        OP_SH_UDI1,     OP_MASK_UDI1,           0},
10514   { '2',        OP_SH_UDI2,     OP_MASK_UDI2,           0},
10515   { '3',        OP_SH_UDI3,     OP_MASK_UDI3,           0},
10516   { '4',        OP_SH_UDI4,     OP_MASK_UDI4,           0},
10517   { 0,0,0,0 }
10518 };
10519
10520 /* Check whether an odd floating-point register is allowed.  */
10521 static int
10522 mips_oddfpreg_ok (const struct mips_opcode *insn, int argnum)
10523 {
10524   const char *s = insn->name;
10525
10526   if (insn->pinfo == INSN_MACRO)
10527     /* Let a macro pass, we'll catch it later when it is expanded.  */
10528     return 1;
10529
10530   if (ISA_HAS_ODD_SINGLE_FPR (mips_opts.isa))
10531     {
10532       /* Allow odd registers for single-precision ops.  */
10533       switch (insn->pinfo & (FP_S | FP_D))
10534         {
10535         case FP_S:
10536         case 0:
10537           return 1;     /* both single precision - ok */
10538         case FP_D:
10539           return 0;     /* both double precision - fail */
10540         default:
10541           break;
10542         }
10543
10544       /* Cvt.w.x and cvt.x.w allow an odd register for a 'w' or 's' operand.  */
10545       s = strchr (insn->name, '.');
10546       if (argnum == 2)
10547         s = s != NULL ? strchr (s + 1, '.') : NULL;
10548       return (s != NULL && (s[1] == 'w' || s[1] == 's'));
10549     } 
10550
10551   /* Single-precision coprocessor loads and moves are OK too.  */
10552   if ((insn->pinfo & FP_S)
10553       && (insn->pinfo & (INSN_COPROC_MEMORY_DELAY | INSN_STORE_MEMORY
10554                          | INSN_LOAD_COPROC_DELAY | INSN_COPROC_MOVE_DELAY)))
10555     return 1;
10556
10557   return 0;
10558 }
10559
10560 /* Check if EXPR is a constant between MIN (inclusive) and MAX (exclusive)
10561    taking bits from BIT up.  */
10562 static int
10563 expr_const_in_range (expressionS *ep, offsetT min, offsetT max, int bit)
10564 {
10565   return (ep->X_op == O_constant
10566           && (ep->X_add_number & ((1 << bit) - 1)) == 0
10567           && ep->X_add_number >= min << bit
10568           && ep->X_add_number < max << bit);
10569 }
10570
10571 /* This routine assembles an instruction into its binary format.  As a
10572    side effect, it sets one of the global variables imm_reloc or
10573    offset_reloc to the type of relocation to do if one of the operands
10574    is an address expression.  */
10575
10576 static void
10577 mips_ip (char *str, struct mips_cl_insn *ip)
10578 {
10579   bfd_boolean wrong_delay_slot_insns = FALSE;
10580   bfd_boolean need_delay_slot_ok = TRUE;
10581   struct mips_opcode *firstinsn = NULL;
10582   const struct mips_opcode *past;
10583   struct hash_control *hash;
10584   char *s;
10585   const char *args;
10586   char c = 0;
10587   struct mips_opcode *insn;
10588   char *argsStart;
10589   unsigned int regno;
10590   unsigned int lastregno;
10591   unsigned int destregno = 0;
10592   unsigned int lastpos = 0;
10593   unsigned int limlo, limhi;
10594   char *s_reset;
10595   offsetT min_range, max_range;
10596   long opend;
10597   char *name;
10598   int argnum;
10599   unsigned int rtype;
10600   char *dot;
10601   long end;
10602
10603   insn_error = NULL;
10604
10605   if (mips_opts.micromips)
10606     {
10607       hash = micromips_op_hash;
10608       past = &micromips_opcodes[bfd_micromips_num_opcodes];
10609     }
10610   else
10611     {
10612       hash = op_hash;
10613       past = &mips_opcodes[NUMOPCODES];
10614     }
10615   forced_insn_length = 0;
10616   insn = NULL;
10617
10618   /* We first try to match an instruction up to a space or to the end.  */
10619   for (end = 0; str[end] != '\0' && !ISSPACE (str[end]); end++)
10620     continue;
10621
10622   /* Make a copy of the instruction so that we can fiddle with it.  */
10623   name = alloca (end + 1);
10624   memcpy (name, str, end);
10625   name[end] = '\0';
10626
10627   for (;;)
10628     {
10629       insn = (struct mips_opcode *) hash_find (hash, name);
10630
10631       if (insn != NULL || !mips_opts.micromips)
10632         break;
10633       if (forced_insn_length)
10634         break;
10635
10636       /* See if there's an instruction size override suffix,
10637          either `16' or `32', at the end of the mnemonic proper,
10638          that defines the operation, i.e. before the first `.'
10639          character if any.  Strip it and retry.  */
10640       dot = strchr (name, '.');
10641       opend = dot != NULL ? dot - name : end;
10642       if (opend < 3)
10643         break;
10644       if (name[opend - 2] == '1' && name[opend - 1] == '6')
10645         forced_insn_length = 2;
10646       else if (name[opend - 2] == '3' && name[opend - 1] == '2')
10647         forced_insn_length = 4;
10648       else
10649         break;
10650       memcpy (name + opend - 2, name + opend, end - opend + 1);
10651     }
10652   if (insn == NULL)
10653     {
10654       insn_error = _("Unrecognized opcode");
10655       return;
10656     }
10657
10658   /* For microMIPS instructions placed in a fixed-length branch delay slot
10659      we make up to two passes over the relevant fragment of the opcode
10660      table.  First we try instructions that meet the delay slot's length
10661      requirement.  If none matched, then we retry with the remaining ones
10662      and if one matches, then we use it and then issue an appropriate
10663      warning later on.  */
10664   argsStart = s = str + end;
10665   for (;;)
10666     {
10667       bfd_boolean delay_slot_ok;
10668       bfd_boolean size_ok;
10669       bfd_boolean ok;
10670
10671       gas_assert (strcmp (insn->name, name) == 0);
10672
10673       ok = is_opcode_valid (insn);
10674       size_ok = is_size_valid (insn);
10675       delay_slot_ok = is_delay_slot_valid (insn);
10676       if (!delay_slot_ok && !wrong_delay_slot_insns)
10677         {
10678           firstinsn = insn;
10679           wrong_delay_slot_insns = TRUE;
10680         }
10681       if (!ok || !size_ok || delay_slot_ok != need_delay_slot_ok)
10682         {
10683           static char buf[256];
10684
10685           if (insn + 1 < past && strcmp (insn->name, insn[1].name) == 0)
10686             {
10687               ++insn;
10688               continue;
10689             }
10690           if (wrong_delay_slot_insns && need_delay_slot_ok)
10691             {
10692               gas_assert (firstinsn);
10693               need_delay_slot_ok = FALSE;
10694               past = insn + 1;
10695               insn = firstinsn;
10696               continue;
10697             }
10698
10699           if (insn_error)
10700             return;
10701
10702           if (!ok)
10703             sprintf (buf, _("opcode not supported on this processor: %s (%s)"),
10704                      mips_cpu_info_from_arch (mips_opts.arch)->name,
10705                      mips_cpu_info_from_isa (mips_opts.isa)->name);
10706           else
10707             sprintf (buf, _("Unrecognized %u-bit version of microMIPS opcode"),
10708                      8 * forced_insn_length);
10709           insn_error = buf;
10710
10711           return;
10712         }
10713
10714       create_insn (ip, insn);
10715       insn_error = NULL;
10716       argnum = 1;
10717       lastregno = 0xffffffff;
10718       for (args = insn->args;; ++args)
10719         {
10720           int is_mdmx;
10721
10722           s += strspn (s, " \t");
10723           is_mdmx = 0;
10724           switch (*args)
10725             {
10726             case '\0':          /* end of args */
10727               if (*s == '\0')
10728                 return;
10729               break;
10730
10731             case '2': /* DSP 2-bit unsigned immediate in bit 11.  */
10732               gas_assert (!mips_opts.micromips);
10733               my_getExpression (&imm_expr, s);
10734               check_absolute_expr (ip, &imm_expr);
10735               if ((unsigned long) imm_expr.X_add_number != 1
10736                   && (unsigned long) imm_expr.X_add_number != 3)
10737                 {
10738                   as_bad (_("BALIGN immediate not 1 or 3 (%lu)"),
10739                           (unsigned long) imm_expr.X_add_number);
10740                 }
10741               INSERT_OPERAND (0, BP, *ip, imm_expr.X_add_number);
10742               imm_expr.X_op = O_absent;
10743               s = expr_end;
10744               continue;
10745
10746             case '3': /* DSP 3-bit unsigned immediate in bit 21.  */
10747               gas_assert (!mips_opts.micromips);
10748               my_getExpression (&imm_expr, s);
10749               check_absolute_expr (ip, &imm_expr);
10750               if (imm_expr.X_add_number & ~OP_MASK_SA3)
10751                 {
10752                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
10753                           OP_MASK_SA3, (unsigned long) imm_expr.X_add_number);
10754                 }
10755               INSERT_OPERAND (0, SA3, *ip, imm_expr.X_add_number);
10756               imm_expr.X_op = O_absent;
10757               s = expr_end;
10758               continue;
10759
10760             case '4': /* DSP 4-bit unsigned immediate in bit 21.  */
10761               gas_assert (!mips_opts.micromips);
10762               my_getExpression (&imm_expr, s);
10763               check_absolute_expr (ip, &imm_expr);
10764               if (imm_expr.X_add_number & ~OP_MASK_SA4)
10765                 {
10766                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
10767                           OP_MASK_SA4, (unsigned long) imm_expr.X_add_number);
10768                 }
10769               INSERT_OPERAND (0, SA4, *ip, imm_expr.X_add_number);
10770               imm_expr.X_op = O_absent;
10771               s = expr_end;
10772               continue;
10773
10774             case '5': /* DSP 8-bit unsigned immediate in bit 16.  */
10775               gas_assert (!mips_opts.micromips);
10776               my_getExpression (&imm_expr, s);
10777               check_absolute_expr (ip, &imm_expr);
10778               if (imm_expr.X_add_number & ~OP_MASK_IMM8)
10779                 {
10780                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
10781                           OP_MASK_IMM8, (unsigned long) imm_expr.X_add_number);
10782                 }
10783               INSERT_OPERAND (0, IMM8, *ip, imm_expr.X_add_number);
10784               imm_expr.X_op = O_absent;
10785               s = expr_end;
10786               continue;
10787
10788             case '6': /* DSP 5-bit unsigned immediate in bit 21.  */
10789               gas_assert (!mips_opts.micromips);
10790               my_getExpression (&imm_expr, s);
10791               check_absolute_expr (ip, &imm_expr);
10792               if (imm_expr.X_add_number & ~OP_MASK_RS)
10793                 {
10794                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
10795                           OP_MASK_RS, (unsigned long) imm_expr.X_add_number);
10796                 }
10797               INSERT_OPERAND (0, RS, *ip, imm_expr.X_add_number);
10798               imm_expr.X_op = O_absent;
10799               s = expr_end;
10800               continue;
10801
10802             case '7': /* Four DSP accumulators in bits 11,12.  */
10803               gas_assert (!mips_opts.micromips);
10804               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
10805                   s[3] >= '0' && s[3] <= '3')
10806                 {
10807                   regno = s[3] - '0';
10808                   s += 4;
10809                   INSERT_OPERAND (0, DSPACC, *ip, regno);
10810                   continue;
10811                 }
10812               else
10813                 as_bad (_("Invalid dsp acc register"));
10814               break;
10815
10816             case '8': /* DSP 6-bit unsigned immediate in bit 11.  */
10817               gas_assert (!mips_opts.micromips);
10818               my_getExpression (&imm_expr, s);
10819               check_absolute_expr (ip, &imm_expr);
10820               if (imm_expr.X_add_number & ~OP_MASK_WRDSP)
10821                 {
10822                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
10823                           OP_MASK_WRDSP,
10824                           (unsigned long) imm_expr.X_add_number);
10825                 }
10826               INSERT_OPERAND (0, WRDSP, *ip, imm_expr.X_add_number);
10827               imm_expr.X_op = O_absent;
10828               s = expr_end;
10829               continue;
10830
10831             case '9': /* Four DSP accumulators in bits 21,22.  */
10832               gas_assert (!mips_opts.micromips);
10833               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
10834                   s[3] >= '0' && s[3] <= '3')
10835                 {
10836                   regno = s[3] - '0';
10837                   s += 4;
10838                   INSERT_OPERAND (0, DSPACC_S, *ip, regno);
10839                   continue;
10840                 }
10841               else
10842                 as_bad (_("Invalid dsp acc register"));
10843               break;
10844
10845             case '0': /* DSP 6-bit signed immediate in bit 20.  */
10846               gas_assert (!mips_opts.micromips);
10847               my_getExpression (&imm_expr, s);
10848               check_absolute_expr (ip, &imm_expr);
10849               min_range = -((OP_MASK_DSPSFT + 1) >> 1);
10850               max_range = ((OP_MASK_DSPSFT + 1) >> 1) - 1;
10851               if (imm_expr.X_add_number < min_range ||
10852                   imm_expr.X_add_number > max_range)
10853                 {
10854                   as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
10855                           (long) min_range, (long) max_range,
10856                           (long) imm_expr.X_add_number);
10857                 }
10858               INSERT_OPERAND (0, DSPSFT, *ip, imm_expr.X_add_number);
10859               imm_expr.X_op = O_absent;
10860               s = expr_end;
10861               continue;
10862
10863             case '\'': /* DSP 6-bit unsigned immediate in bit 16.  */
10864               gas_assert (!mips_opts.micromips);
10865               my_getExpression (&imm_expr, s);
10866               check_absolute_expr (ip, &imm_expr);
10867               if (imm_expr.X_add_number & ~OP_MASK_RDDSP)
10868                 {
10869                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
10870                           OP_MASK_RDDSP,
10871                           (unsigned long) imm_expr.X_add_number);
10872                 }
10873               INSERT_OPERAND (0, RDDSP, *ip, imm_expr.X_add_number);
10874               imm_expr.X_op = O_absent;
10875               s = expr_end;
10876               continue;
10877
10878             case ':': /* DSP 7-bit signed immediate in bit 19.  */
10879               gas_assert (!mips_opts.micromips);
10880               my_getExpression (&imm_expr, s);
10881               check_absolute_expr (ip, &imm_expr);
10882               min_range = -((OP_MASK_DSPSFT_7 + 1) >> 1);
10883               max_range = ((OP_MASK_DSPSFT_7 + 1) >> 1) - 1;
10884               if (imm_expr.X_add_number < min_range ||
10885                   imm_expr.X_add_number > max_range)
10886                 {
10887                   as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
10888                           (long) min_range, (long) max_range,
10889                           (long) imm_expr.X_add_number);
10890                 }
10891               INSERT_OPERAND (0, DSPSFT_7, *ip, imm_expr.X_add_number);
10892               imm_expr.X_op = O_absent;
10893               s = expr_end;
10894               continue;
10895
10896             case '@': /* DSP 10-bit signed immediate in bit 16.  */
10897               gas_assert (!mips_opts.micromips);
10898               my_getExpression (&imm_expr, s);
10899               check_absolute_expr (ip, &imm_expr);
10900               min_range = -((OP_MASK_IMM10 + 1) >> 1);
10901               max_range = ((OP_MASK_IMM10 + 1) >> 1) - 1;
10902               if (imm_expr.X_add_number < min_range ||
10903                   imm_expr.X_add_number > max_range)
10904                 {
10905                   as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
10906                           (long) min_range, (long) max_range,
10907                           (long) imm_expr.X_add_number);
10908                 }
10909               INSERT_OPERAND (0, IMM10, *ip, imm_expr.X_add_number);
10910               imm_expr.X_op = O_absent;
10911               s = expr_end;
10912               continue;
10913
10914             case '!': /* MT usermode flag bit.  */
10915               gas_assert (!mips_opts.micromips);
10916               my_getExpression (&imm_expr, s);
10917               check_absolute_expr (ip, &imm_expr);
10918               if (imm_expr.X_add_number & ~OP_MASK_MT_U)
10919                 as_bad (_("MT usermode bit not 0 or 1 (%lu)"),
10920                         (unsigned long) imm_expr.X_add_number);
10921               INSERT_OPERAND (0, MT_U, *ip, imm_expr.X_add_number);
10922               imm_expr.X_op = O_absent;
10923               s = expr_end;
10924               continue;
10925
10926             case '$': /* MT load high flag bit.  */
10927               gas_assert (!mips_opts.micromips);
10928               my_getExpression (&imm_expr, s);
10929               check_absolute_expr (ip, &imm_expr);
10930               if (imm_expr.X_add_number & ~OP_MASK_MT_H)
10931                 as_bad (_("MT load high bit not 0 or 1 (%lu)"),
10932                         (unsigned long) imm_expr.X_add_number);
10933               INSERT_OPERAND (0, MT_H, *ip, imm_expr.X_add_number);
10934               imm_expr.X_op = O_absent;
10935               s = expr_end;
10936               continue;
10937
10938             case '*': /* Four DSP accumulators in bits 18,19.  */
10939               gas_assert (!mips_opts.micromips);
10940               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
10941                   s[3] >= '0' && s[3] <= '3')
10942                 {
10943                   regno = s[3] - '0';
10944                   s += 4;
10945                   INSERT_OPERAND (0, MTACC_T, *ip, regno);
10946                   continue;
10947                 }
10948               else
10949                 as_bad (_("Invalid dsp/smartmips acc register"));
10950               break;
10951
10952             case '&': /* Four DSP accumulators in bits 13,14.  */
10953               gas_assert (!mips_opts.micromips);
10954               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
10955                   s[3] >= '0' && s[3] <= '3')
10956                 {
10957                   regno = s[3] - '0';
10958                   s += 4;
10959                   INSERT_OPERAND (0, MTACC_D, *ip, regno);
10960                   continue;
10961                 }
10962               else
10963                 as_bad (_("Invalid dsp/smartmips acc register"));
10964               break;
10965
10966             case '\\':          /* 3-bit bit position.  */
10967               {
10968                 unsigned long mask = (mips_opts.micromips
10969                                       ? MICROMIPSOP_MASK_3BITPOS
10970                                       : OP_MASK_3BITPOS);
10971
10972                 my_getExpression (&imm_expr, s);
10973                 check_absolute_expr (ip, &imm_expr);
10974                 if ((unsigned long) imm_expr.X_add_number > mask)
10975                   as_warn (_("Bit position for %s not in range 0..%lu (%lu)"),
10976                            ip->insn_mo->name,
10977                            mask, (unsigned long) imm_expr.X_add_number);
10978                 INSERT_OPERAND (mips_opts.micromips,
10979                                 3BITPOS, *ip, imm_expr.X_add_number);
10980                 imm_expr.X_op = O_absent;
10981                 s = expr_end;
10982               }
10983               continue;
10984
10985             case ',':
10986               ++argnum;
10987               if (*s++ == *args)
10988                 continue;
10989               s--;
10990               switch (*++args)
10991                 {
10992                 case 'r':
10993                 case 'v':
10994                   INSERT_OPERAND (mips_opts.micromips, RS, *ip, lastregno);
10995                   continue;
10996
10997                 case 'w':
10998                   INSERT_OPERAND (mips_opts.micromips, RT, *ip, lastregno);
10999                   continue;
11000
11001                 case 'W':
11002                   gas_assert (!mips_opts.micromips);
11003                   INSERT_OPERAND (0, FT, *ip, lastregno);
11004                   continue;
11005
11006                 case 'V':
11007                   INSERT_OPERAND (mips_opts.micromips, FS, *ip, lastregno);
11008                   continue;
11009                 }
11010               break;
11011
11012             case '(':
11013               /* Handle optional base register.
11014                  Either the base register is omitted or
11015                  we must have a left paren.  */
11016               /* This is dependent on the next operand specifier
11017                  is a base register specification.  */
11018               gas_assert (args[1] == 'b'
11019                           || (mips_opts.micromips
11020                               && args[1] == 'm'
11021                               && (args[2] == 'l' || args[2] == 'n'
11022                                   || args[2] == 's' || args[2] == 'a')));
11023               if (*s == '\0' && args[1] == 'b')
11024                 return;
11025               /* Fall through.  */
11026
11027             case ')':           /* These must match exactly.  */
11028               if (*s++ == *args)
11029                 continue;
11030               break;
11031
11032             case '[':           /* These must match exactly.  */
11033             case ']':
11034               gas_assert (!mips_opts.micromips);
11035               if (*s++ == *args)
11036                 continue;
11037               break;
11038
11039             case '+':           /* Opcode extension character.  */
11040               switch (*++args)
11041                 {
11042                 case '1':       /* UDI immediates.  */
11043                 case '2':
11044                 case '3':
11045                 case '4':
11046                   gas_assert (!mips_opts.micromips);
11047                   {
11048                     const struct mips_immed *imm = mips_immed;
11049
11050                     while (imm->type && imm->type != *args)
11051                       ++imm;
11052                     if (! imm->type)
11053                       internalError ();
11054                     my_getExpression (&imm_expr, s);
11055                     check_absolute_expr (ip, &imm_expr);
11056                     if ((unsigned long) imm_expr.X_add_number & ~imm->mask)
11057                       {
11058                         as_warn (_("Illegal %s number (%lu, 0x%lx)"),
11059                                  imm->desc ? imm->desc : ip->insn_mo->name,
11060                                  (unsigned long) imm_expr.X_add_number,
11061                                  (unsigned long) imm_expr.X_add_number);
11062                         imm_expr.X_add_number &= imm->mask;
11063                       }
11064                     ip->insn_opcode |= ((unsigned long) imm_expr.X_add_number
11065                                         << imm->shift);
11066                     imm_expr.X_op = O_absent;
11067                     s = expr_end;
11068                   }
11069                   continue;
11070
11071                 case 'A':               /* ins/ext position, becomes LSB.  */
11072                   limlo = 0;
11073                   limhi = 31;
11074                   goto do_lsb;
11075                 case 'E':
11076                   limlo = 32;
11077                   limhi = 63;
11078                   goto do_lsb;
11079                 do_lsb:
11080                   my_getExpression (&imm_expr, s);
11081                   check_absolute_expr (ip, &imm_expr);
11082                   if ((unsigned long) imm_expr.X_add_number < limlo
11083                       || (unsigned long) imm_expr.X_add_number > limhi)
11084                     {
11085                       as_bad (_("Improper position (%lu)"),
11086                               (unsigned long) imm_expr.X_add_number);
11087                       imm_expr.X_add_number = limlo;
11088                     }
11089                   lastpos = imm_expr.X_add_number;
11090                   INSERT_OPERAND (mips_opts.micromips,
11091                                   EXTLSB, *ip, imm_expr.X_add_number);
11092                   imm_expr.X_op = O_absent;
11093                   s = expr_end;
11094                   continue;
11095
11096                 case 'B':               /* ins size, becomes MSB.  */
11097                   limlo = 1;
11098                   limhi = 32;
11099                   goto do_msb;
11100                 case 'F':
11101                   limlo = 33;
11102                   limhi = 64;
11103                   goto do_msb;
11104                 do_msb:
11105                   my_getExpression (&imm_expr, s);
11106                   check_absolute_expr (ip, &imm_expr);
11107                   /* Check for negative input so that small negative numbers
11108                      will not succeed incorrectly.  The checks against
11109                      (pos+size) transitively check "size" itself,
11110                      assuming that "pos" is reasonable.  */
11111                   if ((long) imm_expr.X_add_number < 0
11112                       || ((unsigned long) imm_expr.X_add_number
11113                           + lastpos) < limlo
11114                       || ((unsigned long) imm_expr.X_add_number
11115                           + lastpos) > limhi)
11116                     {
11117                       as_bad (_("Improper insert size (%lu, position %lu)"),
11118                               (unsigned long) imm_expr.X_add_number,
11119                               (unsigned long) lastpos);
11120                       imm_expr.X_add_number = limlo - lastpos;
11121                     }
11122                   INSERT_OPERAND (mips_opts.micromips, INSMSB, *ip,
11123                                   lastpos + imm_expr.X_add_number - 1);
11124                   imm_expr.X_op = O_absent;
11125                   s = expr_end;
11126                   continue;
11127
11128                 case 'C':               /* ext size, becomes MSBD.  */
11129                   limlo = 1;
11130                   limhi = 32;
11131                   goto do_msbd;
11132                 case 'G':
11133                   limlo = 33;
11134                   limhi = 64;
11135                   goto do_msbd;
11136                 case 'H':
11137                   limlo = 33;
11138                   limhi = 64;
11139                   goto do_msbd;
11140                 do_msbd:
11141                   my_getExpression (&imm_expr, s);
11142                   check_absolute_expr (ip, &imm_expr);
11143                   /* Check for negative input so that small negative numbers
11144                      will not succeed incorrectly.  The checks against
11145                      (pos+size) transitively check "size" itself,
11146                      assuming that "pos" is reasonable.  */
11147                   if ((long) imm_expr.X_add_number < 0
11148                       || ((unsigned long) imm_expr.X_add_number
11149                           + lastpos) < limlo
11150                       || ((unsigned long) imm_expr.X_add_number
11151                           + lastpos) > limhi)
11152                     {
11153                       as_bad (_("Improper extract size (%lu, position %lu)"),
11154                               (unsigned long) imm_expr.X_add_number,
11155                               (unsigned long) lastpos);
11156                       imm_expr.X_add_number = limlo - lastpos;
11157                     }
11158                   INSERT_OPERAND (mips_opts.micromips,
11159                                   EXTMSBD, *ip, imm_expr.X_add_number - 1);
11160                   imm_expr.X_op = O_absent;
11161                   s = expr_end;
11162                   continue;
11163
11164                 case 'D':
11165                   /* +D is for disassembly only; never match.  */
11166                   break;
11167
11168                 case 'I':
11169                   /* "+I" is like "I", except that imm2_expr is used.  */
11170                   my_getExpression (&imm2_expr, s);
11171                   if (imm2_expr.X_op != O_big
11172                       && imm2_expr.X_op != O_constant)
11173                   insn_error = _("absolute expression required");
11174                   if (HAVE_32BIT_GPRS)
11175                     normalize_constant_expr (&imm2_expr);
11176                   s = expr_end;
11177                   continue;
11178
11179                 case 'T': /* Coprocessor register.  */
11180                   gas_assert (!mips_opts.micromips);
11181                   /* +T is for disassembly only; never match.  */
11182                   break;
11183
11184                 case 't': /* Coprocessor register number.  */
11185                   gas_assert (!mips_opts.micromips);
11186                   if (s[0] == '$' && ISDIGIT (s[1]))
11187                     {
11188                       ++s;
11189                       regno = 0;
11190                       do
11191                         {
11192                           regno *= 10;
11193                           regno += *s - '0';
11194                           ++s;
11195                         }
11196                       while (ISDIGIT (*s));
11197                       if (regno > 31)
11198                         as_bad (_("Invalid register number (%d)"), regno);
11199                       else
11200                         {
11201                           INSERT_OPERAND (0, RT, *ip, regno);
11202                           continue;
11203                         }
11204                     }
11205                   else
11206                     as_bad (_("Invalid coprocessor 0 register number"));
11207                   break;
11208
11209                 case 'x':
11210                   /* bbit[01] and bbit[01]32 bit index.  Give error if index
11211                      is not in the valid range.  */
11212                   gas_assert (!mips_opts.micromips);
11213                   my_getExpression (&imm_expr, s);
11214                   check_absolute_expr (ip, &imm_expr);
11215                   if ((unsigned) imm_expr.X_add_number > 31)
11216                     {
11217                       as_bad (_("Improper bit index (%lu)"),
11218                               (unsigned long) imm_expr.X_add_number);
11219                       imm_expr.X_add_number = 0;
11220                     }
11221                   INSERT_OPERAND (0, BBITIND, *ip, imm_expr.X_add_number);
11222                   imm_expr.X_op = O_absent;
11223                   s = expr_end;
11224                   continue;
11225
11226                 case 'X':
11227                   /* bbit[01] bit index when bbit is used but we generate
11228                      bbit[01]32 because the index is over 32.  Move to the
11229                      next candidate if index is not in the valid range.  */
11230                   gas_assert (!mips_opts.micromips);
11231                   my_getExpression (&imm_expr, s);
11232                   check_absolute_expr (ip, &imm_expr);
11233                   if ((unsigned) imm_expr.X_add_number < 32
11234                       || (unsigned) imm_expr.X_add_number > 63)
11235                     break;
11236                   INSERT_OPERAND (0, BBITIND, *ip, imm_expr.X_add_number - 32);
11237                   imm_expr.X_op = O_absent;
11238                   s = expr_end;
11239                   continue;
11240
11241                 case 'p':
11242                   /* cins, cins32, exts and exts32 position field.  Give error
11243                      if it's not in the valid range.  */
11244                   gas_assert (!mips_opts.micromips);
11245                   my_getExpression (&imm_expr, s);
11246                   check_absolute_expr (ip, &imm_expr);
11247                   if ((unsigned) imm_expr.X_add_number > 31)
11248                     {
11249                       as_bad (_("Improper position (%lu)"),
11250                               (unsigned long) imm_expr.X_add_number);
11251                       imm_expr.X_add_number = 0;
11252                     }
11253                   /* Make the pos explicit to simplify +S.  */
11254                   lastpos = imm_expr.X_add_number + 32;
11255                   INSERT_OPERAND (0, CINSPOS, *ip, imm_expr.X_add_number);
11256                   imm_expr.X_op = O_absent;
11257                   s = expr_end;
11258                   continue;
11259
11260                 case 'P':
11261                   /* cins, cins32, exts and exts32 position field.  Move to
11262                      the next candidate if it's not in the valid range.  */
11263                   gas_assert (!mips_opts.micromips);
11264                   my_getExpression (&imm_expr, s);
11265                   check_absolute_expr (ip, &imm_expr);
11266                   if ((unsigned) imm_expr.X_add_number < 32
11267                       || (unsigned) imm_expr.X_add_number > 63)
11268                     break;
11269                   lastpos = imm_expr.X_add_number;
11270                   INSERT_OPERAND (0, CINSPOS, *ip, imm_expr.X_add_number - 32);
11271                   imm_expr.X_op = O_absent;
11272                   s = expr_end;
11273                   continue;
11274
11275                 case 's':
11276                   /* cins and exts length-minus-one field.  */
11277                   gas_assert (!mips_opts.micromips);
11278                   my_getExpression (&imm_expr, s);
11279                   check_absolute_expr (ip, &imm_expr);
11280                   if ((unsigned long) imm_expr.X_add_number > 31)
11281                     {
11282                       as_bad (_("Improper size (%lu)"),
11283                               (unsigned long) imm_expr.X_add_number);
11284                       imm_expr.X_add_number = 0;
11285                     }
11286                   INSERT_OPERAND (0, CINSLM1, *ip, imm_expr.X_add_number);
11287                   imm_expr.X_op = O_absent;
11288                   s = expr_end;
11289                   continue;
11290
11291                 case 'S':
11292                   /* cins32/exts32 and cins/exts aliasing cint32/exts32
11293                      length-minus-one field.  */
11294                   gas_assert (!mips_opts.micromips);
11295                   my_getExpression (&imm_expr, s);
11296                   check_absolute_expr (ip, &imm_expr);
11297                   if ((long) imm_expr.X_add_number < 0
11298                       || (unsigned long) imm_expr.X_add_number + lastpos > 63)
11299                     {
11300                       as_bad (_("Improper size (%lu)"),
11301                               (unsigned long) imm_expr.X_add_number);
11302                       imm_expr.X_add_number = 0;
11303                     }
11304                   INSERT_OPERAND (0, CINSLM1, *ip, imm_expr.X_add_number);
11305                   imm_expr.X_op = O_absent;
11306                   s = expr_end;
11307                   continue;
11308
11309                 case 'Q':
11310                   /* seqi/snei immediate field.  */
11311                   gas_assert (!mips_opts.micromips);
11312                   my_getExpression (&imm_expr, s);
11313                   check_absolute_expr (ip, &imm_expr);
11314                   if ((long) imm_expr.X_add_number < -512
11315                       || (long) imm_expr.X_add_number >= 512)
11316                     {
11317                       as_bad (_("Improper immediate (%ld)"),
11318                                (long) imm_expr.X_add_number);
11319                       imm_expr.X_add_number = 0;
11320                     }
11321                   INSERT_OPERAND (0, SEQI, *ip, imm_expr.X_add_number);
11322                   imm_expr.X_op = O_absent;
11323                   s = expr_end;
11324                   continue;
11325
11326                 case 'a': /* 8-bit signed offset in bit 6 */
11327                   gas_assert (!mips_opts.micromips);
11328                   my_getExpression (&imm_expr, s);
11329                   check_absolute_expr (ip, &imm_expr);
11330                   min_range = -((OP_MASK_OFFSET_A + 1) >> 1);
11331                   max_range = ((OP_MASK_OFFSET_A + 1) >> 1) - 1;
11332                   if (imm_expr.X_add_number < min_range
11333                       || imm_expr.X_add_number > max_range)
11334                     {
11335                       as_bad (_("Offset not in range %ld..%ld (%ld)"),
11336                               (long) min_range, (long) max_range,
11337                               (long) imm_expr.X_add_number);
11338                     }
11339                   INSERT_OPERAND (0, OFFSET_A, *ip, imm_expr.X_add_number);
11340                   imm_expr.X_op = O_absent;
11341                   s = expr_end;
11342                   continue;
11343
11344                 case 'b': /* 8-bit signed offset in bit 3 */
11345                   gas_assert (!mips_opts.micromips);
11346                   my_getExpression (&imm_expr, s);
11347                   check_absolute_expr (ip, &imm_expr);
11348                   min_range = -((OP_MASK_OFFSET_B + 1) >> 1);
11349                   max_range = ((OP_MASK_OFFSET_B + 1) >> 1) - 1;
11350                   if (imm_expr.X_add_number < min_range
11351                       || imm_expr.X_add_number > max_range)
11352                     {
11353                       as_bad (_("Offset not in range %ld..%ld (%ld)"),
11354                               (long) min_range, (long) max_range,
11355                               (long) imm_expr.X_add_number);
11356                     }
11357                   INSERT_OPERAND (0, OFFSET_B, *ip, imm_expr.X_add_number);
11358                   imm_expr.X_op = O_absent;
11359                   s = expr_end;
11360                   continue;
11361
11362                 case 'c': /* 9-bit signed offset in bit 6 */
11363                   gas_assert (!mips_opts.micromips);
11364                   my_getExpression (&imm_expr, s);
11365                   check_absolute_expr (ip, &imm_expr);
11366                   min_range = -((OP_MASK_OFFSET_C + 1) >> 1);
11367                   max_range = ((OP_MASK_OFFSET_C + 1) >> 1) - 1;
11368                   /* We check the offset range before adjusted.  */
11369                   min_range <<= 4;
11370                   max_range <<= 4;
11371                   if (imm_expr.X_add_number < min_range
11372                       || imm_expr.X_add_number > max_range)
11373                     {
11374                       as_bad (_("Offset not in range %ld..%ld (%ld)"),
11375                               (long) min_range, (long) max_range,
11376                               (long) imm_expr.X_add_number);
11377                     }
11378                   if (imm_expr.X_add_number & 0xf)
11379                     {
11380                       as_bad (_("Offset not 16 bytes alignment (%ld)"),
11381                               (long) imm_expr.X_add_number);
11382                     }
11383                   /* Right shift 4 bits to adjust the offset operand.  */
11384                   INSERT_OPERAND (0, OFFSET_C, *ip,
11385                                   imm_expr.X_add_number >> 4);
11386                   imm_expr.X_op = O_absent;
11387                   s = expr_end;
11388                   continue;
11389
11390                 case 'z':
11391                   gas_assert (!mips_opts.micromips);
11392                   if (!reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &regno))
11393                     break;
11394                   if (regno == AT && mips_opts.at)
11395                     {
11396                       if (mips_opts.at == ATREG)
11397                         as_warn (_("used $at without \".set noat\""));
11398                       else
11399                         as_warn (_("used $%u with \".set at=$%u\""),
11400                                  regno, mips_opts.at);
11401                     }
11402                   INSERT_OPERAND (0, RZ, *ip, regno);
11403                   continue;
11404
11405                 case 'Z':
11406                   gas_assert (!mips_opts.micromips);
11407                   if (!reg_lookup (&s, RTYPE_FPU, &regno))
11408                     break;
11409                   INSERT_OPERAND (0, FZ, *ip, regno);
11410                   continue;
11411
11412                 default:
11413                   as_bad (_("Internal error: bad %s opcode "
11414                             "(unknown extension operand type `+%c'): %s %s"),
11415                           mips_opts.micromips ? "microMIPS" : "MIPS",
11416                           *args, insn->name, insn->args);
11417                   /* Further processing is fruitless.  */
11418                   return;
11419                 }
11420               break;
11421
11422             case '.':           /* 10-bit offset.  */
11423               gas_assert (mips_opts.micromips);
11424             case '~':           /* 12-bit offset.  */
11425               {
11426                 int shift = *args == '.' ? 9 : 11;
11427                 size_t i;
11428
11429                 /* Check whether there is only a single bracketed expression
11430                    left.  If so, it must be the base register and the
11431                    constant must be zero.  */
11432                 if (*s == '(' && strchr (s + 1, '(') == 0)
11433                   continue;
11434
11435                 /* If this value won't fit into the offset, then go find
11436                    a macro that will generate a 16- or 32-bit offset code
11437                    pattern.  */
11438                 i = my_getSmallExpression (&imm_expr, imm_reloc, s);
11439                 if ((i == 0 && (imm_expr.X_op != O_constant
11440                                 || imm_expr.X_add_number >= 1 << shift
11441                                 || imm_expr.X_add_number < -1 << shift))
11442                     || i > 0)
11443                   {
11444                     imm_expr.X_op = O_absent;
11445                     break;
11446                   }
11447                 if (shift == 9)
11448                   INSERT_OPERAND (1, OFFSET10, *ip, imm_expr.X_add_number);
11449                 else
11450                   INSERT_OPERAND (mips_opts.micromips,
11451                                   OFFSET12, *ip, imm_expr.X_add_number);
11452                 imm_expr.X_op = O_absent;
11453                 s = expr_end;
11454               }
11455               continue;
11456
11457             case '<':           /* must be at least one digit */
11458               /*
11459                * According to the manual, if the shift amount is greater
11460                * than 31 or less than 0, then the shift amount should be
11461                * mod 32.  In reality the mips assembler issues an error.
11462                * We issue a warning and mask out all but the low 5 bits.
11463                */
11464               my_getExpression (&imm_expr, s);
11465               check_absolute_expr (ip, &imm_expr);
11466               if ((unsigned long) imm_expr.X_add_number > 31)
11467                 as_warn (_("Improper shift amount (%lu)"),
11468                          (unsigned long) imm_expr.X_add_number);
11469               INSERT_OPERAND (mips_opts.micromips,
11470                               SHAMT, *ip, imm_expr.X_add_number);
11471               imm_expr.X_op = O_absent;
11472               s = expr_end;
11473               continue;
11474
11475             case '>':           /* shift amount minus 32 */
11476               my_getExpression (&imm_expr, s);
11477               check_absolute_expr (ip, &imm_expr);
11478               if ((unsigned long) imm_expr.X_add_number < 32
11479                   || (unsigned long) imm_expr.X_add_number > 63)
11480                 break;
11481               INSERT_OPERAND (mips_opts.micromips,
11482                               SHAMT, *ip, imm_expr.X_add_number - 32);
11483               imm_expr.X_op = O_absent;
11484               s = expr_end;
11485               continue;
11486
11487             case 'k':           /* CACHE code.  */
11488             case 'h':           /* PREFX code.  */
11489             case '1':           /* SYNC type.  */
11490               my_getExpression (&imm_expr, s);
11491               check_absolute_expr (ip, &imm_expr);
11492               if ((unsigned long) imm_expr.X_add_number > 31)
11493                 as_warn (_("Invalid value for `%s' (%lu)"),
11494                          ip->insn_mo->name,
11495                          (unsigned long) imm_expr.X_add_number);
11496               switch (*args)
11497                 {
11498                 case 'k':
11499                   if (mips_fix_cn63xxp1
11500                       && !mips_opts.micromips
11501                       && strcmp ("pref", insn->name) == 0)
11502                     switch (imm_expr.X_add_number)
11503                       {
11504                       case 5:
11505                       case 25:
11506                       case 26:
11507                       case 27:
11508                       case 28:
11509                       case 29:
11510                       case 30:
11511                       case 31:  /* These are ok.  */
11512                         break;
11513
11514                       default:  /* The rest must be changed to 28.  */
11515                         imm_expr.X_add_number = 28;
11516                         break;
11517                       }
11518                   INSERT_OPERAND (mips_opts.micromips,
11519                                   CACHE, *ip, imm_expr.X_add_number);
11520                   break;
11521                 case 'h':
11522                   INSERT_OPERAND (mips_opts.micromips,
11523                                   PREFX, *ip, imm_expr.X_add_number);
11524                   break;
11525                 case '1':
11526                   INSERT_OPERAND (mips_opts.micromips,
11527                                   STYPE, *ip, imm_expr.X_add_number);
11528                   break;
11529                 }
11530               imm_expr.X_op = O_absent;
11531               s = expr_end;
11532               continue;
11533
11534             case 'c':           /* BREAK code.  */
11535               {
11536                 unsigned long mask = (mips_opts.micromips
11537                                       ? MICROMIPSOP_MASK_CODE
11538                                       : OP_MASK_CODE);
11539
11540                 my_getExpression (&imm_expr, s);
11541                 check_absolute_expr (ip, &imm_expr);
11542                 if ((unsigned long) imm_expr.X_add_number > mask)
11543                   as_warn (_("Code for %s not in range 0..%lu (%lu)"),
11544                            ip->insn_mo->name,
11545                            mask, (unsigned long) imm_expr.X_add_number);
11546                 INSERT_OPERAND (mips_opts.micromips,
11547                                 CODE, *ip, imm_expr.X_add_number);
11548                 imm_expr.X_op = O_absent;
11549                 s = expr_end;
11550               }
11551               continue;
11552
11553             case 'q':           /* Lower BREAK code.  */
11554               {
11555                 unsigned long mask = (mips_opts.micromips
11556                                       ? MICROMIPSOP_MASK_CODE2
11557                                       : OP_MASK_CODE2);
11558
11559                 my_getExpression (&imm_expr, s);
11560                 check_absolute_expr (ip, &imm_expr);
11561                 if ((unsigned long) imm_expr.X_add_number > mask)
11562                   as_warn (_("Lower code for %s not in range 0..%lu (%lu)"),
11563                            ip->insn_mo->name,
11564                            mask, (unsigned long) imm_expr.X_add_number);
11565                 INSERT_OPERAND (mips_opts.micromips,
11566                                 CODE2, *ip, imm_expr.X_add_number);
11567                 imm_expr.X_op = O_absent;
11568                 s = expr_end;
11569               }
11570               continue;
11571
11572             case 'B':           /* 20- or 10-bit syscall/break/wait code.  */
11573               {
11574                 unsigned long mask = (mips_opts.micromips
11575                                       ? MICROMIPSOP_MASK_CODE10
11576                                       : OP_MASK_CODE20);
11577
11578                 my_getExpression (&imm_expr, s);
11579                 check_absolute_expr (ip, &imm_expr);
11580                 if ((unsigned long) imm_expr.X_add_number > mask)
11581                   as_warn (_("Code for %s not in range 0..%lu (%lu)"),
11582                            ip->insn_mo->name,
11583                            mask, (unsigned long) imm_expr.X_add_number);
11584                 if (mips_opts.micromips)
11585                   INSERT_OPERAND (1, CODE10, *ip, imm_expr.X_add_number);
11586                 else
11587                   INSERT_OPERAND (0, CODE20, *ip, imm_expr.X_add_number);
11588                 imm_expr.X_op = O_absent;
11589                 s = expr_end;
11590               }
11591               continue;
11592
11593             case 'C':           /* 25- or 23-bit coprocessor code.  */
11594               {
11595                 unsigned long mask = (mips_opts.micromips
11596                                       ? MICROMIPSOP_MASK_COPZ
11597                                       : OP_MASK_COPZ);
11598
11599                 my_getExpression (&imm_expr, s);
11600                 check_absolute_expr (ip, &imm_expr);
11601                 if ((unsigned long) imm_expr.X_add_number > mask)
11602                   as_warn (_("Coproccesor code > %u bits (%lu)"),
11603                            mips_opts.micromips ? 23U : 25U,
11604                            (unsigned long) imm_expr.X_add_number);
11605                 INSERT_OPERAND (mips_opts.micromips,
11606                                 COPZ, *ip, imm_expr.X_add_number);
11607                 imm_expr.X_op = O_absent;
11608                 s = expr_end;
11609               }
11610               continue;
11611
11612             case 'J':           /* 19-bit WAIT code.  */
11613               gas_assert (!mips_opts.micromips);
11614               my_getExpression (&imm_expr, s);
11615               check_absolute_expr (ip, &imm_expr);
11616               if ((unsigned long) imm_expr.X_add_number > OP_MASK_CODE19)
11617                 {
11618                   as_warn (_("Illegal 19-bit code (%lu)"),
11619                            (unsigned long) imm_expr.X_add_number);
11620                   imm_expr.X_add_number &= OP_MASK_CODE19;
11621                 }
11622               INSERT_OPERAND (0, CODE19, *ip, imm_expr.X_add_number);
11623               imm_expr.X_op = O_absent;
11624               s = expr_end;
11625               continue;
11626
11627             case 'P':           /* Performance register.  */
11628               gas_assert (!mips_opts.micromips);
11629               my_getExpression (&imm_expr, s);
11630               check_absolute_expr (ip, &imm_expr);
11631               if (imm_expr.X_add_number != 0 && imm_expr.X_add_number != 1)
11632                 as_warn (_("Invalid performance register (%lu)"),
11633                          (unsigned long) imm_expr.X_add_number);
11634               INSERT_OPERAND (0, PERFREG, *ip, imm_expr.X_add_number);
11635               imm_expr.X_op = O_absent;
11636               s = expr_end;
11637               continue;
11638
11639             case 'G':           /* Coprocessor destination register.  */
11640               {
11641                 unsigned long opcode = ip->insn_opcode;
11642                 unsigned long mask;
11643                 unsigned int types;
11644                 int cop0;
11645
11646                 if (mips_opts.micromips)
11647                   {
11648                     mask = ~((MICROMIPSOP_MASK_RT << MICROMIPSOP_SH_RT)
11649                              | (MICROMIPSOP_MASK_RS << MICROMIPSOP_SH_RS)
11650                              | (MICROMIPSOP_MASK_SEL << MICROMIPSOP_SH_SEL));
11651                     opcode &= mask;
11652                     switch (opcode)
11653                       {
11654                       case 0x000000fc:                          /* mfc0  */
11655                       case 0x000002fc:                          /* mtc0  */
11656                       case 0x580000fc:                          /* dmfc0 */
11657                       case 0x580002fc:                          /* dmtc0 */
11658                         cop0 = 1;
11659                         break;
11660                       default:
11661                         cop0 = 0;
11662                         break;
11663                       }
11664                   }
11665                 else
11666                   {
11667                     opcode = (opcode >> OP_SH_OP) & OP_MASK_OP;
11668                     cop0 = opcode == OP_OP_COP0;
11669                   }
11670                 types = RTYPE_NUM | (cop0 ? RTYPE_CP0 : RTYPE_GP);
11671                 ok = reg_lookup (&s, types, &regno);
11672                 if (mips_opts.micromips)
11673                   INSERT_OPERAND (1, RS, *ip, regno);
11674                 else
11675                   INSERT_OPERAND (0, RD, *ip, regno);
11676                 if (ok)
11677                   {
11678                     lastregno = regno;
11679                     continue;
11680                   }
11681               }
11682               break;
11683
11684             case 'y':           /* ALNV.PS source register.  */
11685               gas_assert (mips_opts.micromips);
11686               goto do_reg;
11687             case 'x':           /* Ignore register name.  */
11688             case 'U':           /* Destination register (CLO/CLZ).  */
11689             case 'g':           /* Coprocessor destination register.  */
11690               gas_assert (!mips_opts.micromips);
11691             case 'b':           /* Base register.  */
11692             case 'd':           /* Destination register.  */
11693             case 's':           /* Source register.  */
11694             case 't':           /* Target register.  */
11695             case 'r':           /* Both target and source.  */
11696             case 'v':           /* Both dest and source.  */
11697             case 'w':           /* Both dest and target.  */
11698             case 'E':           /* Coprocessor target register.  */
11699             case 'K':           /* RDHWR destination register.  */
11700             case 'z':           /* Must be zero register.  */
11701             do_reg:
11702               s_reset = s;
11703               if (*args == 'E' || *args == 'K')
11704                 ok = reg_lookup (&s, RTYPE_NUM, &regno);
11705               else
11706                 {
11707                   ok = reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &regno);
11708                   if (regno == AT && mips_opts.at)
11709                     {
11710                       if (mips_opts.at == ATREG)
11711                         as_warn (_("Used $at without \".set noat\""));
11712                       else
11713                         as_warn (_("Used $%u with \".set at=$%u\""),
11714                                  regno, mips_opts.at);
11715                     }
11716                 }
11717               if (ok)
11718                 {
11719                   c = *args;
11720                   if (*s == ' ')
11721                     ++s;
11722                   if (args[1] != *s)
11723                     {
11724                       if (c == 'r' || c == 'v' || c == 'w')
11725                         {
11726                           regno = lastregno;
11727                           s = s_reset;
11728                           ++args;
11729                         }
11730                     }
11731                   /* 'z' only matches $0.  */
11732                   if (c == 'z' && regno != 0)
11733                     break;
11734
11735                   if (c == 's' && !strncmp (ip->insn_mo->name, "jalr", 4))
11736                     {
11737                       if (regno == lastregno)
11738                         {
11739                           insn_error
11740                             = _("Source and destination must be different");
11741                           continue;
11742                         }
11743                       if (regno == 31 && lastregno == 0xffffffff)
11744                         {
11745                           insn_error
11746                             = _("A destination register must be supplied");
11747                           continue;
11748                         }
11749                     }
11750                   /* Now that we have assembled one operand, we use the args
11751                      string to figure out where it goes in the instruction.  */
11752                   switch (c)
11753                     {
11754                     case 'r':
11755                     case 's':
11756                     case 'v':
11757                     case 'b':
11758                       INSERT_OPERAND (mips_opts.micromips, RS, *ip, regno);
11759                       break;
11760
11761                     case 'K':
11762                       if (mips_opts.micromips)
11763                         INSERT_OPERAND (1, RS, *ip, regno);
11764                       else
11765                         INSERT_OPERAND (0, RD, *ip, regno);
11766                       break;
11767
11768                     case 'd':
11769                     case 'g':
11770                       INSERT_OPERAND (mips_opts.micromips, RD, *ip, regno);
11771                       break;
11772
11773                     case 'U':
11774                       gas_assert (!mips_opts.micromips);
11775                       INSERT_OPERAND (0, RD, *ip, regno);
11776                       INSERT_OPERAND (0, RT, *ip, regno);
11777                       break;
11778
11779                     case 'w':
11780                     case 't':
11781                     case 'E':
11782                       INSERT_OPERAND (mips_opts.micromips, RT, *ip, regno);
11783                       break;
11784
11785                     case 'y':
11786                       gas_assert (mips_opts.micromips);
11787                       INSERT_OPERAND (1, RS3, *ip, regno);
11788                       break;
11789
11790                     case 'x':
11791                       /* This case exists because on the r3000 trunc
11792                          expands into a macro which requires a gp
11793                          register.  On the r6000 or r4000 it is
11794                          assembled into a single instruction which
11795                          ignores the register.  Thus the insn version
11796                          is MIPS_ISA2 and uses 'x', and the macro
11797                          version is MIPS_ISA1 and uses 't'.  */
11798                       break;
11799
11800                     case 'z':
11801                       /* This case is for the div instruction, which
11802                          acts differently if the destination argument
11803                          is $0.  This only matches $0, and is checked
11804                          outside the switch.  */
11805                       break;
11806                     }
11807                   lastregno = regno;
11808                   continue;
11809                 }
11810               switch (*args++)
11811                 {
11812                 case 'r':
11813                 case 'v':
11814                   INSERT_OPERAND (mips_opts.micromips, RS, *ip, lastregno);
11815                   continue;
11816
11817                 case 'w':
11818                   INSERT_OPERAND (mips_opts.micromips, RT, *ip, lastregno);
11819                   continue;
11820                 }
11821               break;
11822
11823             case 'O':           /* MDMX alignment immediate constant.  */
11824               gas_assert (!mips_opts.micromips);
11825               my_getExpression (&imm_expr, s);
11826               check_absolute_expr (ip, &imm_expr);
11827               if ((unsigned long) imm_expr.X_add_number > OP_MASK_ALN)
11828                 as_warn (_("Improper align amount (%ld), using low bits"),
11829                          (long) imm_expr.X_add_number);
11830               INSERT_OPERAND (0, ALN, *ip, imm_expr.X_add_number);
11831               imm_expr.X_op = O_absent;
11832               s = expr_end;
11833               continue;
11834
11835             case 'Q':           /* MDMX vector, element sel, or const.  */
11836               if (s[0] != '$')
11837                 {
11838                   /* MDMX Immediate.  */
11839                   gas_assert (!mips_opts.micromips);
11840                   my_getExpression (&imm_expr, s);
11841                   check_absolute_expr (ip, &imm_expr);
11842                   if ((unsigned long) imm_expr.X_add_number > OP_MASK_FT)
11843                     as_warn (_("Invalid MDMX Immediate (%ld)"),
11844                              (long) imm_expr.X_add_number);
11845                   INSERT_OPERAND (0, FT, *ip, imm_expr.X_add_number);
11846                   if (ip->insn_opcode & (OP_MASK_VSEL << OP_SH_VSEL))
11847                     ip->insn_opcode |= MDMX_FMTSEL_IMM_QH << OP_SH_VSEL;
11848                   else
11849                     ip->insn_opcode |= MDMX_FMTSEL_IMM_OB << OP_SH_VSEL;
11850                   imm_expr.X_op = O_absent;
11851                   s = expr_end;
11852                   continue;
11853                 }
11854               /* Not MDMX Immediate.  Fall through.  */
11855             case 'X':           /* MDMX destination register.  */
11856             case 'Y':           /* MDMX source register.  */
11857             case 'Z':           /* MDMX target register.  */
11858               is_mdmx = 1;
11859             case 'W':
11860               gas_assert (!mips_opts.micromips);
11861             case 'D':           /* Floating point destination register.  */
11862             case 'S':           /* Floating point source register.  */
11863             case 'T':           /* Floating point target register.  */
11864             case 'R':           /* Floating point source register.  */
11865             case 'V':
11866               rtype = RTYPE_FPU;
11867               if (is_mdmx
11868                   || (mips_opts.ase_mdmx
11869                       && (ip->insn_mo->pinfo & FP_D)
11870                       && (ip->insn_mo->pinfo & (INSN_COPROC_MOVE_DELAY
11871                                                 | INSN_COPROC_MEMORY_DELAY
11872                                                 | INSN_LOAD_COPROC_DELAY
11873                                                 | INSN_LOAD_MEMORY_DELAY
11874                                                 | INSN_STORE_MEMORY))))
11875                 rtype |= RTYPE_VEC;
11876               s_reset = s;
11877               if (reg_lookup (&s, rtype, &regno))
11878                 {
11879                   if ((regno & 1) != 0
11880                       && HAVE_32BIT_FPRS
11881                       && !mips_oddfpreg_ok (ip->insn_mo, argnum))
11882                     as_warn (_("Float register should be even, was %d"),
11883                              regno);
11884
11885                   c = *args;
11886                   if (*s == ' ')
11887                     ++s;
11888                   if (args[1] != *s)
11889                     {
11890                       if (c == 'V' || c == 'W')
11891                         {
11892                           regno = lastregno;
11893                           s = s_reset;
11894                           ++args;
11895                         }
11896                     }
11897                   switch (c)
11898                     {
11899                     case 'D':
11900                     case 'X':
11901                       INSERT_OPERAND (mips_opts.micromips, FD, *ip, regno);
11902                       break;
11903
11904                     case 'V':
11905                     case 'S':
11906                     case 'Y':
11907                       INSERT_OPERAND (mips_opts.micromips, FS, *ip, regno);
11908                       break;
11909
11910                     case 'Q':
11911                       /* This is like 'Z', but also needs to fix the MDMX
11912                          vector/scalar select bits.  Note that the
11913                          scalar immediate case is handled above.  */
11914                       if (*s == '[')
11915                         {
11916                           int is_qh = (ip->insn_opcode & (1 << OP_SH_VSEL));
11917                           int max_el = (is_qh ? 3 : 7);
11918                           s++;
11919                           my_getExpression(&imm_expr, s);
11920                           check_absolute_expr (ip, &imm_expr);
11921                           s = expr_end;
11922                           if (imm_expr.X_add_number > max_el)
11923                             as_bad (_("Bad element selector %ld"),
11924                                     (long) imm_expr.X_add_number);
11925                           imm_expr.X_add_number &= max_el;
11926                           ip->insn_opcode |= (imm_expr.X_add_number
11927                                               << (OP_SH_VSEL +
11928                                                   (is_qh ? 2 : 1)));
11929                           imm_expr.X_op = O_absent;
11930                           if (*s != ']')
11931                             as_warn (_("Expecting ']' found '%s'"), s);
11932                           else
11933                             s++;
11934                         }
11935                       else
11936                         {
11937                           if (ip->insn_opcode & (OP_MASK_VSEL << OP_SH_VSEL))
11938                             ip->insn_opcode |= (MDMX_FMTSEL_VEC_QH
11939                                                 << OP_SH_VSEL);
11940                           else
11941                             ip->insn_opcode |= (MDMX_FMTSEL_VEC_OB <<
11942                                                 OP_SH_VSEL);
11943                         }
11944                       /* Fall through.  */
11945                     case 'W':
11946                     case 'T':
11947                     case 'Z':
11948                       INSERT_OPERAND (mips_opts.micromips, FT, *ip, regno);
11949                       break;
11950
11951                     case 'R':
11952                       INSERT_OPERAND (mips_opts.micromips, FR, *ip, regno);
11953                       break;
11954                     }
11955                   lastregno = regno;
11956                   continue;
11957                 }
11958
11959               switch (*args++)
11960                 {
11961                 case 'V':
11962                   INSERT_OPERAND (mips_opts.micromips, FS, *ip, lastregno);
11963                   continue;
11964
11965                 case 'W':
11966                   INSERT_OPERAND (mips_opts.micromips, FT, *ip, lastregno);
11967                   continue;
11968                 }
11969               break;
11970
11971             case 'I':
11972               my_getExpression (&imm_expr, s);
11973               if (imm_expr.X_op != O_big
11974                   && imm_expr.X_op != O_constant)
11975                 insn_error = _("absolute expression required");
11976               if (HAVE_32BIT_GPRS)
11977                 normalize_constant_expr (&imm_expr);
11978               s = expr_end;
11979               continue;
11980
11981             case 'A':
11982               my_getExpression (&offset_expr, s);
11983               normalize_address_expr (&offset_expr);
11984               *imm_reloc = BFD_RELOC_32;
11985               s = expr_end;
11986               continue;
11987
11988             case 'F':
11989             case 'L':
11990             case 'f':
11991             case 'l':
11992               {
11993                 int f64;
11994                 int using_gprs;
11995                 char *save_in;
11996                 char *err;
11997                 unsigned char temp[8];
11998                 int len;
11999                 unsigned int length;
12000                 segT seg;
12001                 subsegT subseg;
12002                 char *p;
12003
12004                 /* These only appear as the last operand in an
12005                    instruction, and every instruction that accepts
12006                    them in any variant accepts them in all variants.
12007                    This means we don't have to worry about backing out
12008                    any changes if the instruction does not match.
12009
12010                    The difference between them is the size of the
12011                    floating point constant and where it goes.  For 'F'
12012                    and 'L' the constant is 64 bits; for 'f' and 'l' it
12013                    is 32 bits.  Where the constant is placed is based
12014                    on how the MIPS assembler does things:
12015                     F -- .rdata
12016                     L -- .lit8
12017                     f -- immediate value
12018                     l -- .lit4
12019
12020                     The .lit4 and .lit8 sections are only used if
12021                     permitted by the -G argument.
12022
12023                     The code below needs to know whether the target register
12024                     is 32 or 64 bits wide.  It relies on the fact 'f' and
12025                     'F' are used with GPR-based instructions and 'l' and
12026                     'L' are used with FPR-based instructions.  */
12027
12028                 f64 = *args == 'F' || *args == 'L';
12029                 using_gprs = *args == 'F' || *args == 'f';
12030
12031                 save_in = input_line_pointer;
12032                 input_line_pointer = s;
12033                 err = md_atof (f64 ? 'd' : 'f', (char *) temp, &len);
12034                 length = len;
12035                 s = input_line_pointer;
12036                 input_line_pointer = save_in;
12037                 if (err != NULL && *err != '\0')
12038                   {
12039                     as_bad (_("Bad floating point constant: %s"), err);
12040                     memset (temp, '\0', sizeof temp);
12041                     length = f64 ? 8 : 4;
12042                   }
12043
12044                 gas_assert (length == (unsigned) (f64 ? 8 : 4));
12045
12046                 if (*args == 'f'
12047                     || (*args == 'l'
12048                         && (g_switch_value < 4
12049                             || (temp[0] == 0 && temp[1] == 0)
12050                             || (temp[2] == 0 && temp[3] == 0))))
12051                   {
12052                     imm_expr.X_op = O_constant;
12053                     if (!target_big_endian)
12054                       imm_expr.X_add_number = bfd_getl32 (temp);
12055                     else
12056                       imm_expr.X_add_number = bfd_getb32 (temp);
12057                   }
12058                 else if (length > 4
12059                          && !mips_disable_float_construction
12060                          /* Constants can only be constructed in GPRs and
12061                             copied to FPRs if the GPRs are at least as wide
12062                             as the FPRs.  Force the constant into memory if
12063                             we are using 64-bit FPRs but the GPRs are only
12064                             32 bits wide.  */
12065                          && (using_gprs
12066                              || !(HAVE_64BIT_FPRS && HAVE_32BIT_GPRS))
12067                          && ((temp[0] == 0 && temp[1] == 0)
12068                              || (temp[2] == 0 && temp[3] == 0))
12069                          && ((temp[4] == 0 && temp[5] == 0)
12070                              || (temp[6] == 0 && temp[7] == 0)))
12071                   {
12072                     /* The value is simple enough to load with a couple of
12073                        instructions.  If using 32-bit registers, set
12074                        imm_expr to the high order 32 bits and offset_expr to
12075                        the low order 32 bits.  Otherwise, set imm_expr to
12076                        the entire 64 bit constant.  */
12077                     if (using_gprs ? HAVE_32BIT_GPRS : HAVE_32BIT_FPRS)
12078                       {
12079                         imm_expr.X_op = O_constant;
12080                         offset_expr.X_op = O_constant;
12081                         if (!target_big_endian)
12082                           {
12083                             imm_expr.X_add_number = bfd_getl32 (temp + 4);
12084                             offset_expr.X_add_number = bfd_getl32 (temp);
12085                           }
12086                         else
12087                           {
12088                             imm_expr.X_add_number = bfd_getb32 (temp);
12089                             offset_expr.X_add_number = bfd_getb32 (temp + 4);
12090                           }
12091                         if (offset_expr.X_add_number == 0)
12092                           offset_expr.X_op = O_absent;
12093                       }
12094                     else if (sizeof (imm_expr.X_add_number) > 4)
12095                       {
12096                         imm_expr.X_op = O_constant;
12097                         if (!target_big_endian)
12098                           imm_expr.X_add_number = bfd_getl64 (temp);
12099                         else
12100                           imm_expr.X_add_number = bfd_getb64 (temp);
12101                       }
12102                     else
12103                       {
12104                         imm_expr.X_op = O_big;
12105                         imm_expr.X_add_number = 4;
12106                         if (!target_big_endian)
12107                           {
12108                             generic_bignum[0] = bfd_getl16 (temp);
12109                             generic_bignum[1] = bfd_getl16 (temp + 2);
12110                             generic_bignum[2] = bfd_getl16 (temp + 4);
12111                             generic_bignum[3] = bfd_getl16 (temp + 6);
12112                           }
12113                         else
12114                           {
12115                             generic_bignum[0] = bfd_getb16 (temp + 6);
12116                             generic_bignum[1] = bfd_getb16 (temp + 4);
12117                             generic_bignum[2] = bfd_getb16 (temp + 2);
12118                             generic_bignum[3] = bfd_getb16 (temp);
12119                           }
12120                       }
12121                   }
12122                 else
12123                   {
12124                     const char *newname;
12125                     segT new_seg;
12126
12127                     /* Switch to the right section.  */
12128                     seg = now_seg;
12129                     subseg = now_subseg;
12130                     switch (*args)
12131                       {
12132                       default: /* unused default case avoids warnings.  */
12133                       case 'L':
12134                         newname = RDATA_SECTION_NAME;
12135                         if (g_switch_value >= 8)
12136                           newname = ".lit8";
12137                         break;
12138                       case 'F':
12139                         newname = RDATA_SECTION_NAME;
12140                         break;
12141                       case 'l':
12142                         gas_assert (g_switch_value >= 4);
12143                         newname = ".lit4";
12144                         break;
12145                       }
12146                     new_seg = subseg_new (newname, (subsegT) 0);
12147                     if (IS_ELF)
12148                       bfd_set_section_flags (stdoutput, new_seg,
12149                                              (SEC_ALLOC
12150                                               | SEC_LOAD
12151                                               | SEC_READONLY
12152                                               | SEC_DATA));
12153                     frag_align (*args == 'l' ? 2 : 3, 0, 0);
12154                     if (IS_ELF && strncmp (TARGET_OS, "elf", 3) != 0)
12155                       record_alignment (new_seg, 4);
12156                     else
12157                       record_alignment (new_seg, *args == 'l' ? 2 : 3);
12158                     if (seg == now_seg)
12159                       as_bad (_("Can't use floating point insn in this section"));
12160
12161                     /* Set the argument to the current address in the
12162                        section.  */
12163                     offset_expr.X_op = O_symbol;
12164                     offset_expr.X_add_symbol = symbol_temp_new_now ();
12165                     offset_expr.X_add_number = 0;
12166
12167                     /* Put the floating point number into the section.  */
12168                     p = frag_more ((int) length);
12169                     memcpy (p, temp, length);
12170
12171                     /* Switch back to the original section.  */
12172                     subseg_set (seg, subseg);
12173                   }
12174               }
12175               continue;
12176
12177             case 'i':           /* 16-bit unsigned immediate.  */
12178             case 'j':           /* 16-bit signed immediate.  */
12179               *imm_reloc = BFD_RELOC_LO16;
12180               if (my_getSmallExpression (&imm_expr, imm_reloc, s) == 0)
12181                 {
12182                   int more;
12183                   offsetT minval, maxval;
12184
12185                   more = (insn + 1 < past
12186                           && strcmp (insn->name, insn[1].name) == 0);
12187
12188                   /* If the expression was written as an unsigned number,
12189                      only treat it as signed if there are no more
12190                      alternatives.  */
12191                   if (more
12192                       && *args == 'j'
12193                       && sizeof (imm_expr.X_add_number) <= 4
12194                       && imm_expr.X_op == O_constant
12195                       && imm_expr.X_add_number < 0
12196                       && imm_expr.X_unsigned
12197                       && HAVE_64BIT_GPRS)
12198                     break;
12199
12200                   /* For compatibility with older assemblers, we accept
12201                      0x8000-0xffff as signed 16-bit numbers when only
12202                      signed numbers are allowed.  */
12203                   if (*args == 'i')
12204                     minval = 0, maxval = 0xffff;
12205                   else if (more)
12206                     minval = -0x8000, maxval = 0x7fff;
12207                   else
12208                     minval = -0x8000, maxval = 0xffff;
12209
12210                   if (imm_expr.X_op != O_constant
12211                       || imm_expr.X_add_number < minval
12212                       || imm_expr.X_add_number > maxval)
12213                     {
12214                       if (more)
12215                         break;
12216                       if (imm_expr.X_op == O_constant
12217                           || imm_expr.X_op == O_big)
12218                         as_bad (_("Expression out of range"));
12219                     }
12220                 }
12221               s = expr_end;
12222               continue;
12223
12224             case 'o':           /* 16-bit offset.  */
12225               offset_reloc[0] = BFD_RELOC_LO16;
12226               offset_reloc[1] = BFD_RELOC_UNUSED;
12227               offset_reloc[2] = BFD_RELOC_UNUSED;
12228
12229               /* Check whether there is only a single bracketed expression
12230                  left.  If so, it must be the base register and the
12231                  constant must be zero.  */
12232               if (*s == '(' && strchr (s + 1, '(') == 0)
12233                 {
12234                   offset_expr.X_op = O_constant;
12235                   offset_expr.X_add_number = 0;
12236                   continue;
12237                 }
12238
12239               /* If this value won't fit into a 16 bit offset, then go
12240                  find a macro that will generate the 32 bit offset
12241                  code pattern.  */
12242               if (my_getSmallExpression (&offset_expr, offset_reloc, s) == 0
12243                   && (offset_expr.X_op != O_constant
12244                       || offset_expr.X_add_number >= 0x8000
12245                       || offset_expr.X_add_number < -0x8000))
12246                 break;
12247
12248               s = expr_end;
12249               continue;
12250
12251             case 'p':           /* PC-relative offset.  */
12252               *offset_reloc = BFD_RELOC_16_PCREL_S2;
12253               my_getExpression (&offset_expr, s);
12254               s = expr_end;
12255               continue;
12256
12257             case 'u':           /* Upper 16 bits.  */
12258               if (my_getSmallExpression (&imm_expr, imm_reloc, s) == 0
12259                   && imm_expr.X_op == O_constant
12260                   && (imm_expr.X_add_number < 0
12261                       || imm_expr.X_add_number >= 0x10000))
12262                 as_bad (_("lui expression (%lu) not in range 0..65535"),
12263                         (unsigned long) imm_expr.X_add_number);
12264               s = expr_end;
12265               continue;
12266
12267             case 'a':           /* 26-bit address.  */
12268               *offset_reloc = BFD_RELOC_MIPS_JMP;
12269               my_getExpression (&offset_expr, s);
12270               s = expr_end;
12271               continue;
12272
12273             case 'N':           /* 3-bit branch condition code.  */
12274             case 'M':           /* 3-bit compare condition code.  */
12275               rtype = RTYPE_CCC;
12276               if (ip->insn_mo->pinfo & (FP_D | FP_S))
12277                 rtype |= RTYPE_FCC;
12278               if (!reg_lookup (&s, rtype, &regno))
12279                 break;
12280               if ((strcmp (str + strlen (str) - 3, ".ps") == 0
12281                    || strcmp (str + strlen (str) - 5, "any2f") == 0
12282                    || strcmp (str + strlen (str) - 5, "any2t") == 0)
12283                   && (regno & 1) != 0)
12284                 as_warn (_("Condition code register should be even for %s, "
12285                            "was %d"),
12286                          str, regno);
12287               if ((strcmp (str + strlen (str) - 5, "any4f") == 0
12288                    || strcmp (str + strlen (str) - 5, "any4t") == 0)
12289                   && (regno & 3) != 0)
12290                 as_warn (_("Condition code register should be 0 or 4 for %s, "
12291                            "was %d"),
12292                          str, regno);
12293               if (*args == 'N')
12294                 INSERT_OPERAND (mips_opts.micromips, BCC, *ip, regno);
12295               else
12296                 INSERT_OPERAND (mips_opts.micromips, CCC, *ip, regno);
12297               continue;
12298
12299             case 'H':
12300               if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
12301                 s += 2;
12302               if (ISDIGIT (*s))
12303                 {
12304                   c = 0;
12305                   do
12306                     {
12307                       c *= 10;
12308                       c += *s - '0';
12309                       ++s;
12310                     }
12311                   while (ISDIGIT (*s));
12312                 }
12313               else
12314                 c = 8; /* Invalid sel value.  */
12315
12316               if (c > 7)
12317                 as_bad (_("Invalid coprocessor sub-selection value (0-7)"));
12318               INSERT_OPERAND (mips_opts.micromips, SEL, *ip, c);
12319               continue;
12320
12321             case 'e':
12322               gas_assert (!mips_opts.micromips);
12323               /* Must be at least one digit.  */
12324               my_getExpression (&imm_expr, s);
12325               check_absolute_expr (ip, &imm_expr);
12326
12327               if ((unsigned long) imm_expr.X_add_number
12328                   > (unsigned long) OP_MASK_VECBYTE)
12329                 {
12330                   as_bad (_("bad byte vector index (%ld)"),
12331                            (long) imm_expr.X_add_number);
12332                   imm_expr.X_add_number = 0;
12333                 }
12334
12335               INSERT_OPERAND (0, VECBYTE, *ip, imm_expr.X_add_number);
12336               imm_expr.X_op = O_absent;
12337               s = expr_end;
12338               continue;
12339
12340             case '%':
12341               gas_assert (!mips_opts.micromips);
12342               my_getExpression (&imm_expr, s);
12343               check_absolute_expr (ip, &imm_expr);
12344
12345               if ((unsigned long) imm_expr.X_add_number
12346                   > (unsigned long) OP_MASK_VECALIGN)
12347                 {
12348                   as_bad (_("bad byte vector index (%ld)"),
12349                            (long) imm_expr.X_add_number);
12350                   imm_expr.X_add_number = 0;
12351                 }
12352
12353               INSERT_OPERAND (0, VECALIGN, *ip, imm_expr.X_add_number);
12354               imm_expr.X_op = O_absent;
12355               s = expr_end;
12356               continue;
12357
12358             case 'm':           /* Opcode extension character.  */
12359               gas_assert (mips_opts.micromips);
12360               c = *++args;
12361               switch (c)
12362                 {
12363                 case 'r':
12364                   if (strncmp (s, "$pc", 3) == 0)
12365                     {
12366                       s += 3;
12367                       continue;
12368                     }
12369                   break;
12370
12371                 case 'a':
12372                 case 'b':
12373                 case 'c':
12374                 case 'd':
12375                 case 'e':
12376                 case 'f':
12377                 case 'g':
12378                 case 'h':
12379                 case 'i':
12380                 case 'j':
12381                 case 'l':
12382                 case 'm':
12383                 case 'n':
12384                 case 'p':
12385                 case 'q':
12386                 case 's':
12387                 case 't':
12388                 case 'x':
12389                 case 'y':
12390                 case 'z':
12391                   s_reset = s;
12392                   ok = reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &regno);
12393                   if (regno == AT && mips_opts.at)
12394                     {
12395                       if (mips_opts.at == ATREG)
12396                         as_warn (_("Used $at without \".set noat\""));
12397                       else
12398                         as_warn (_("Used $%u with \".set at=$%u\""),
12399                                  regno, mips_opts.at);
12400                     }
12401                   if (!ok)
12402                     {
12403                       if (c == 'c')
12404                         {
12405                           gas_assert (args[1] == ',');
12406                           regno = lastregno;
12407                           ++args;
12408                         }
12409                       else if (c == 't')
12410                         {
12411                           gas_assert (args[1] == ',');
12412                           ++args;
12413                           continue;                     /* Nothing to do.  */
12414                         }
12415                       else
12416                         break;
12417                     }
12418
12419                   if (c == 'j' && !strncmp (ip->insn_mo->name, "jalr", 4))
12420                     {
12421                       if (regno == lastregno)
12422                         {
12423                           insn_error
12424                             = _("Source and destination must be different");
12425                           continue;
12426                         }
12427                       if (regno == 31 && lastregno == 0xffffffff)
12428                         {
12429                           insn_error
12430                             = _("A destination register must be supplied");
12431                           continue;
12432                         }
12433                     }
12434
12435                   if (*s == ' ')
12436                     ++s;
12437                   if (args[1] != *s)
12438                     {
12439                       if (c == 'e')
12440                         {
12441                           gas_assert (args[1] == ',');
12442                           regno = lastregno;
12443                           s = s_reset;
12444                           ++args;
12445                         }
12446                       else if (c == 't')
12447                         {
12448                           gas_assert (args[1] == ',');
12449                           s = s_reset;
12450                           ++args;
12451                           continue;                     /* Nothing to do.  */
12452                         }
12453                     }
12454
12455                   /* Make sure regno is the same as lastregno.  */
12456                   if (c == 't' && regno != lastregno)
12457                     break;
12458
12459                   /* Make sure regno is the same as destregno.  */
12460                   if (c == 'x' && regno != destregno)
12461                     break;
12462
12463                   /* We need to save regno, before regno maps to the
12464                      microMIPS register encoding.  */
12465                   lastregno = regno;
12466
12467                   if (c == 'f')
12468                     destregno = regno;
12469
12470                   switch (c)
12471                     {
12472                       case 'a':
12473                         if (regno != GP)
12474                           regno = ILLEGAL_REG;
12475                         break;
12476
12477                       case 'b':
12478                         regno = mips32_to_micromips_reg_b_map[regno];
12479                         break;
12480
12481                       case 'c':
12482                         regno = mips32_to_micromips_reg_c_map[regno];
12483                         break;
12484
12485                       case 'd':
12486                         regno = mips32_to_micromips_reg_d_map[regno];
12487                         break;
12488
12489                       case 'e':
12490                         regno = mips32_to_micromips_reg_e_map[regno];
12491                         break;
12492
12493                       case 'f':
12494                         regno = mips32_to_micromips_reg_f_map[regno];
12495                         break;
12496
12497                       case 'g':
12498                         regno = mips32_to_micromips_reg_g_map[regno];
12499                         break;
12500
12501                       case 'h':
12502                         regno = mips32_to_micromips_reg_h_map[regno];
12503                         break;
12504
12505                       case 'i':
12506                         switch (EXTRACT_OPERAND (1, MI, *ip))
12507                           {
12508                             case 4:
12509                               if (regno == 21)
12510                                 regno = 3;
12511                               else if (regno == 22)
12512                                 regno = 4;
12513                               else if (regno == 5)
12514                                 regno = 5;
12515                               else if (regno == 6)
12516                                 regno = 6;
12517                               else if (regno == 7)
12518                                 regno = 7;
12519                               else
12520                                 regno = ILLEGAL_REG;
12521                               break;
12522
12523                             case 5:
12524                               if (regno == 6)
12525                                 regno = 0;
12526                               else if (regno == 7)
12527                                 regno = 1;
12528                               else
12529                                 regno = ILLEGAL_REG;
12530                               break;
12531
12532                             case 6:
12533                               if (regno == 7)
12534                                 regno = 2;
12535                               else
12536                                 regno = ILLEGAL_REG;
12537                               break;
12538
12539                             default:
12540                               regno = ILLEGAL_REG;
12541                               break;
12542                           }
12543                         break;
12544
12545                       case 'l':
12546                         regno = mips32_to_micromips_reg_l_map[regno];
12547                         break;
12548
12549                       case 'm':
12550                         regno = mips32_to_micromips_reg_m_map[regno];
12551                         break;
12552
12553                       case 'n':
12554                         regno = mips32_to_micromips_reg_n_map[regno];
12555                         break;
12556
12557                       case 'q':
12558                         regno = mips32_to_micromips_reg_q_map[regno];
12559                         break;
12560
12561                       case 's':
12562                         if (regno != SP)
12563                           regno = ILLEGAL_REG;
12564                         break;
12565
12566                       case 'y':
12567                         if (regno != 31)
12568                           regno = ILLEGAL_REG;
12569                         break;
12570
12571                       case 'z':
12572                         if (regno != ZERO)
12573                           regno = ILLEGAL_REG;
12574                         break;
12575
12576                       case 'j': /* Do nothing.  */
12577                       case 'p':
12578                       case 't':
12579                       case 'x':
12580                         break;
12581
12582                       default:
12583                         internalError ();
12584                     }
12585
12586                   if (regno == ILLEGAL_REG)
12587                     break;
12588
12589                   switch (c)
12590                     {
12591                       case 'b':
12592                         INSERT_OPERAND (1, MB, *ip, regno);
12593                         break;
12594
12595                       case 'c':
12596                         INSERT_OPERAND (1, MC, *ip, regno);
12597                         break;
12598
12599                       case 'd':
12600                         INSERT_OPERAND (1, MD, *ip, regno);
12601                         break;
12602
12603                       case 'e':
12604                         INSERT_OPERAND (1, ME, *ip, regno);
12605                         break;
12606
12607                       case 'f':
12608                         INSERT_OPERAND (1, MF, *ip, regno);
12609                         break;
12610
12611                       case 'g':
12612                         INSERT_OPERAND (1, MG, *ip, regno);
12613                         break;
12614
12615                       case 'h':
12616                         INSERT_OPERAND (1, MH, *ip, regno);
12617                         break;
12618
12619                       case 'i':
12620                         INSERT_OPERAND (1, MI, *ip, regno);
12621                         break;
12622
12623                       case 'j':
12624                         INSERT_OPERAND (1, MJ, *ip, regno);
12625                         break;
12626
12627                       case 'l':
12628                         INSERT_OPERAND (1, ML, *ip, regno);
12629                         break;
12630
12631                       case 'm':
12632                         INSERT_OPERAND (1, MM, *ip, regno);
12633                         break;
12634
12635                       case 'n':
12636                         INSERT_OPERAND (1, MN, *ip, regno);
12637                         break;
12638
12639                       case 'p':
12640                         INSERT_OPERAND (1, MP, *ip, regno);
12641                         break;
12642
12643                       case 'q':
12644                         INSERT_OPERAND (1, MQ, *ip, regno);
12645                         break;
12646
12647                       case 'a': /* Do nothing.  */
12648                       case 's': /* Do nothing.  */
12649                       case 't': /* Do nothing.  */
12650                       case 'x': /* Do nothing.  */
12651                       case 'y': /* Do nothing.  */
12652                       case 'z': /* Do nothing.  */
12653                         break;
12654
12655                       default:
12656                         internalError ();
12657                     }
12658                   continue;
12659
12660                 case 'A':
12661                   {
12662                     bfd_reloc_code_real_type r[3];
12663                     expressionS ep;
12664                     int imm;
12665
12666                     /* Check whether there is only a single bracketed
12667                        expression left.  If so, it must be the base register
12668                        and the constant must be zero.  */
12669                     if (*s == '(' && strchr (s + 1, '(') == 0)
12670                       {
12671                         INSERT_OPERAND (1, IMMA, *ip, 0);
12672                         continue;
12673                       }
12674
12675                     if (my_getSmallExpression (&ep, r, s) > 0
12676                         || !expr_const_in_range (&ep, -64, 64, 2))
12677                       break;
12678
12679                     imm = ep.X_add_number >> 2;
12680                     INSERT_OPERAND (1, IMMA, *ip, imm);
12681                   }
12682                   s = expr_end;
12683                   continue;
12684
12685                 case 'B':
12686                   {
12687                     bfd_reloc_code_real_type r[3];
12688                     expressionS ep;
12689                     int imm;
12690
12691                     if (my_getSmallExpression (&ep, r, s) > 0
12692                         || ep.X_op != O_constant)
12693                       break;
12694
12695                     for (imm = 0; imm < 8; imm++)
12696                       if (micromips_imm_b_map[imm] == ep.X_add_number)
12697                         break;
12698                     if (imm >= 8)
12699                       break;
12700
12701                     INSERT_OPERAND (1, IMMB, *ip, imm);
12702                   }
12703                   s = expr_end;
12704                   continue;
12705
12706                 case 'C':
12707                   {
12708                     bfd_reloc_code_real_type r[3];
12709                     expressionS ep;
12710                     int imm;
12711
12712                     if (my_getSmallExpression (&ep, r, s) > 0
12713                         || ep.X_op != O_constant)
12714                       break;
12715
12716                     for (imm = 0; imm < 16; imm++)
12717                       if (micromips_imm_c_map[imm] == ep.X_add_number)
12718                         break;
12719                     if (imm >= 16)
12720                       break;
12721
12722                     INSERT_OPERAND (1, IMMC, *ip, imm);
12723                   }
12724                   s = expr_end;
12725                   continue;
12726
12727                 case 'D':       /* pc relative offset */
12728                 case 'E':       /* pc relative offset */
12729                   my_getExpression (&offset_expr, s);
12730                   if (offset_expr.X_op == O_register)
12731                     break;
12732
12733                   if (!forced_insn_length)
12734                     *offset_reloc = (int) BFD_RELOC_UNUSED + c;
12735                   else if (c == 'D')
12736                     *offset_reloc = BFD_RELOC_MICROMIPS_10_PCREL_S1;
12737                   else
12738                     *offset_reloc = BFD_RELOC_MICROMIPS_7_PCREL_S1;
12739                   s = expr_end;
12740                   continue;
12741
12742                 case 'F':
12743                   {
12744                     bfd_reloc_code_real_type r[3];
12745                     expressionS ep;
12746                     int imm;
12747
12748                     if (my_getSmallExpression (&ep, r, s) > 0
12749                         || !expr_const_in_range (&ep, 0, 16, 0))
12750                       break;
12751
12752                     imm = ep.X_add_number;
12753                     INSERT_OPERAND (1, IMMF, *ip, imm);
12754                   }
12755                   s = expr_end;
12756                   continue;
12757
12758                 case 'G':
12759                   {
12760                     bfd_reloc_code_real_type r[3];
12761                     expressionS ep;
12762                     int imm;
12763
12764                     /* Check whether there is only a single bracketed
12765                        expression left.  If so, it must be the base register
12766                        and the constant must be zero.  */
12767                     if (*s == '(' && strchr (s + 1, '(') == 0)
12768                       {
12769                         INSERT_OPERAND (1, IMMG, *ip, 0);
12770                         continue;
12771                       }
12772
12773                     if (my_getSmallExpression (&ep, r, s) > 0
12774                         || !expr_const_in_range (&ep, -1, 15, 0))
12775                       break;
12776
12777                     imm = ep.X_add_number & 15;
12778                     INSERT_OPERAND (1, IMMG, *ip, imm);
12779                   }
12780                   s = expr_end;
12781                   continue;
12782
12783                 case 'H':
12784                   {
12785                     bfd_reloc_code_real_type r[3];
12786                     expressionS ep;
12787                     int imm;
12788
12789                     /* Check whether there is only a single bracketed
12790                        expression left.  If so, it must be the base register
12791                        and the constant must be zero.  */
12792                     if (*s == '(' && strchr (s + 1, '(') == 0)
12793                       {
12794                         INSERT_OPERAND (1, IMMH, *ip, 0);
12795                         continue;
12796                       }
12797
12798                     if (my_getSmallExpression (&ep, r, s) > 0
12799                         || !expr_const_in_range (&ep, 0, 16, 1))
12800                       break;
12801
12802                     imm = ep.X_add_number >> 1;
12803                     INSERT_OPERAND (1, IMMH, *ip, imm);
12804                   }
12805                   s = expr_end;
12806                   continue;
12807
12808                 case 'I':
12809                   {
12810                     bfd_reloc_code_real_type r[3];
12811                     expressionS ep;
12812                     int imm;
12813
12814                     if (my_getSmallExpression (&ep, r, s) > 0
12815                         || !expr_const_in_range (&ep, -1, 127, 0))
12816                       break;
12817
12818                     imm = ep.X_add_number & 127;
12819                     INSERT_OPERAND (1, IMMI, *ip, imm);
12820                   }
12821                   s = expr_end;
12822                   continue;
12823
12824                 case 'J':
12825                   {
12826                     bfd_reloc_code_real_type r[3];
12827                     expressionS ep;
12828                     int imm;
12829
12830                     /* Check whether there is only a single bracketed
12831                        expression left.  If so, it must be the base register
12832                        and the constant must be zero.  */
12833                     if (*s == '(' && strchr (s + 1, '(') == 0)
12834                       {
12835                         INSERT_OPERAND (1, IMMJ, *ip, 0);
12836                         continue;
12837                       }
12838
12839                     if (my_getSmallExpression (&ep, r, s) > 0
12840                         || !expr_const_in_range (&ep, 0, 16, 2))
12841                       break;
12842
12843                     imm = ep.X_add_number >> 2;
12844                     INSERT_OPERAND (1, IMMJ, *ip, imm);
12845                   }
12846                   s = expr_end;
12847                   continue;
12848
12849                 case 'L':
12850                   {
12851                     bfd_reloc_code_real_type r[3];
12852                     expressionS ep;
12853                     int imm;
12854
12855                     /* Check whether there is only a single bracketed
12856                        expression left.  If so, it must be the base register
12857                        and the constant must be zero.  */
12858                     if (*s == '(' && strchr (s + 1, '(') == 0)
12859                       {
12860                         INSERT_OPERAND (1, IMML, *ip, 0);
12861                         continue;
12862                       }
12863
12864                     if (my_getSmallExpression (&ep, r, s) > 0
12865                         || !expr_const_in_range (&ep, 0, 16, 0))
12866                       break;
12867
12868                     imm = ep.X_add_number;
12869                     INSERT_OPERAND (1, IMML, *ip, imm);
12870                   }
12871                   s = expr_end;
12872                   continue;
12873
12874                 case 'M':
12875                   {
12876                     bfd_reloc_code_real_type r[3];
12877                     expressionS ep;
12878                     int imm;
12879
12880                     if (my_getSmallExpression (&ep, r, s) > 0
12881                         || !expr_const_in_range (&ep, 1, 9, 0))
12882                       break;
12883
12884                     imm = ep.X_add_number & 7;
12885                     INSERT_OPERAND (1, IMMM, *ip, imm);
12886                   }
12887                   s = expr_end;
12888                   continue;
12889
12890                 case 'N':       /* Register list for lwm and swm.  */
12891                   {
12892                     /* A comma-separated list of registers and/or
12893                        dash-separated contiguous ranges including
12894                        both ra and a set of one or more registers
12895                        starting at s0 up to s3 which have to be
12896                        consecutive, e.g.:
12897
12898                        s0, ra
12899                        s0, s1, ra, s2, s3
12900                        s0-s2, ra
12901
12902                        and any permutations of these.  */
12903                     unsigned int reglist;
12904                     int imm;
12905
12906                     if (!reglist_lookup (&s, RTYPE_NUM | RTYPE_GP, &reglist))
12907                       break;
12908
12909                     if ((reglist & 0xfff1ffff) != 0x80010000)
12910                       break;
12911
12912                     reglist = (reglist >> 17) & 7;
12913                     reglist += 1;
12914                     if ((reglist & -reglist) != reglist)
12915                       break;
12916
12917                     imm = ffs (reglist) - 1;
12918                     INSERT_OPERAND (1, IMMN, *ip, imm);
12919                   }
12920                   continue;
12921
12922                 case 'O':       /* sdbbp 4-bit code.  */
12923                   {
12924                     bfd_reloc_code_real_type r[3];
12925                     expressionS ep;
12926                     int imm;
12927
12928                     if (my_getSmallExpression (&ep, r, s) > 0
12929                         || !expr_const_in_range (&ep, 0, 16, 0))
12930                       break;
12931
12932                     imm = ep.X_add_number;
12933                     INSERT_OPERAND (1, IMMO, *ip, imm);
12934                   }
12935                   s = expr_end;
12936                   continue;
12937
12938                 case 'P':
12939                   {
12940                     bfd_reloc_code_real_type r[3];
12941                     expressionS ep;
12942                     int imm;
12943
12944                     if (my_getSmallExpression (&ep, r, s) > 0
12945                         || !expr_const_in_range (&ep, 0, 32, 2))
12946                       break;
12947
12948                     imm = ep.X_add_number >> 2;
12949                     INSERT_OPERAND (1, IMMP, *ip, imm);
12950                   }
12951                   s = expr_end;
12952                   continue;
12953
12954                 case 'Q':
12955                   {
12956                     bfd_reloc_code_real_type r[3];
12957                     expressionS ep;
12958                     int imm;
12959
12960                     if (my_getSmallExpression (&ep, r, s) > 0
12961                         || !expr_const_in_range (&ep, -0x400000, 0x400000, 2))
12962                       break;
12963
12964                     imm = ep.X_add_number >> 2;
12965                     INSERT_OPERAND (1, IMMQ, *ip, imm);
12966                   }
12967                   s = expr_end;
12968                   continue;
12969
12970                 case 'U':
12971                   {
12972                     bfd_reloc_code_real_type r[3];
12973                     expressionS ep;
12974                     int imm;
12975
12976                     /* Check whether there is only a single bracketed
12977                        expression left.  If so, it must be the base register
12978                        and the constant must be zero.  */
12979                     if (*s == '(' && strchr (s + 1, '(') == 0)
12980                       {
12981                         INSERT_OPERAND (1, IMMU, *ip, 0);
12982                         continue;
12983                       }
12984
12985                     if (my_getSmallExpression (&ep, r, s) > 0
12986                         || !expr_const_in_range (&ep, 0, 32, 2))
12987                       break;
12988
12989                     imm = ep.X_add_number >> 2;
12990                     INSERT_OPERAND (1, IMMU, *ip, imm);
12991                   }
12992                   s = expr_end;
12993                   continue;
12994
12995                 case 'W':
12996                   {
12997                     bfd_reloc_code_real_type r[3];
12998                     expressionS ep;
12999                     int imm;
13000
13001                     if (my_getSmallExpression (&ep, r, s) > 0
13002                         || !expr_const_in_range (&ep, 0, 64, 2))
13003                       break;
13004
13005                     imm = ep.X_add_number >> 2;
13006                     INSERT_OPERAND (1, IMMW, *ip, imm);
13007                   }
13008                   s = expr_end;
13009                   continue;
13010
13011                 case 'X':
13012                   {
13013                     bfd_reloc_code_real_type r[3];
13014                     expressionS ep;
13015                     int imm;
13016
13017                     if (my_getSmallExpression (&ep, r, s) > 0
13018                         || !expr_const_in_range (&ep, -8, 8, 0))
13019                       break;
13020
13021                     imm = ep.X_add_number;
13022                     INSERT_OPERAND (1, IMMX, *ip, imm);
13023                   }
13024                   s = expr_end;
13025                   continue;
13026
13027                 case 'Y':
13028                   {
13029                     bfd_reloc_code_real_type r[3];
13030                     expressionS ep;
13031                     int imm;
13032
13033                     if (my_getSmallExpression (&ep, r, s) > 0
13034                         || expr_const_in_range (&ep, -2, 2, 2)
13035                         || !expr_const_in_range (&ep, -258, 258, 2))
13036                       break;
13037
13038                     imm = ep.X_add_number >> 2;
13039                     imm = ((imm >> 1) & ~0xff) | (imm & 0xff);
13040                     INSERT_OPERAND (1, IMMY, *ip, imm);
13041                   }
13042                   s = expr_end;
13043                   continue;
13044
13045                 case 'Z':
13046                   {
13047                     bfd_reloc_code_real_type r[3];
13048                     expressionS ep;
13049
13050                     if (my_getSmallExpression (&ep, r, s) > 0
13051                         || !expr_const_in_range (&ep, 0, 1, 0))
13052                       break;
13053                   }
13054                   s = expr_end;
13055                   continue;
13056
13057                 default:
13058                   as_bad (_("Internal error: bad microMIPS opcode "
13059                             "(unknown extension operand type `m%c'): %s %s"),
13060                           *args, insn->name, insn->args);
13061                   /* Further processing is fruitless.  */
13062                   return;
13063                 }
13064               break;
13065
13066             case 'n':           /* Register list for 32-bit lwm and swm.  */
13067               gas_assert (mips_opts.micromips);
13068               {
13069                 /* A comma-separated list of registers and/or
13070                    dash-separated contiguous ranges including
13071                    at least one of ra and a set of one or more
13072                    registers starting at s0 up to s7 and then
13073                    s8 which have to be consecutive, e.g.:
13074
13075                    ra
13076                    s0
13077                    ra, s0, s1, s2
13078                    s0-s8
13079                    s0-s5, ra
13080
13081                    and any permutations of these.  */
13082                 unsigned int reglist;
13083                 int imm;
13084                 int ra;
13085
13086                 if (!reglist_lookup (&s, RTYPE_NUM | RTYPE_GP, &reglist))
13087                   break;
13088
13089                 if ((reglist & 0x3f00ffff) != 0)
13090                   break;
13091
13092                 ra = (reglist >> 27) & 0x10;
13093                 reglist = ((reglist >> 22) & 0x100) | ((reglist >> 16) & 0xff);
13094                 reglist += 1;
13095                 if ((reglist & -reglist) != reglist)
13096                   break;
13097
13098                 imm = (ffs (reglist) - 1) | ra;
13099                 INSERT_OPERAND (1, RT, *ip, imm);
13100                 imm_expr.X_op = O_absent;
13101               }
13102               continue;
13103
13104             case '|':           /* 4-bit trap code.  */
13105               gas_assert (mips_opts.micromips);
13106               my_getExpression (&imm_expr, s);
13107               check_absolute_expr (ip, &imm_expr);
13108               if ((unsigned long) imm_expr.X_add_number
13109                   > MICROMIPSOP_MASK_TRAP)
13110                 as_bad (_("Trap code (%lu) for %s not in 0..15 range"),
13111                         (unsigned long) imm_expr.X_add_number,
13112                         ip->insn_mo->name);
13113               INSERT_OPERAND (1, TRAP, *ip, imm_expr.X_add_number);
13114               imm_expr.X_op = O_absent;
13115               s = expr_end;
13116               continue;
13117
13118             default:
13119               as_bad (_("Bad char = '%c'\n"), *args);
13120               internalError ();
13121             }
13122           break;
13123         }
13124       /* Args don't match.  */
13125       s = argsStart;
13126       insn_error = _("Illegal operands");
13127       if (insn + 1 < past && !strcmp (insn->name, insn[1].name))
13128         {
13129           ++insn;
13130           continue;
13131         }
13132       else if (wrong_delay_slot_insns && need_delay_slot_ok)
13133         {
13134           gas_assert (firstinsn);
13135           need_delay_slot_ok = FALSE;
13136           past = insn + 1;
13137           insn = firstinsn;
13138           continue;
13139         }
13140       return;
13141     }
13142 }
13143
13144 #define SKIP_SPACE_TABS(S) { while (*(S) == ' ' || *(S) == '\t') ++(S); }
13145
13146 /* This routine assembles an instruction into its binary format when
13147    assembling for the mips16.  As a side effect, it sets one of the
13148    global variables imm_reloc or offset_reloc to the type of relocation
13149    to do if one of the operands is an address expression.  It also sets
13150    forced_insn_length to the resulting instruction size in bytes if the
13151    user explicitly requested a small or extended instruction.  */
13152
13153 static void
13154 mips16_ip (char *str, struct mips_cl_insn *ip)
13155 {
13156   char *s;
13157   const char *args;
13158   struct mips_opcode *insn;
13159   char *argsstart;
13160   unsigned int regno;
13161   unsigned int lastregno = 0;
13162   char *s_reset;
13163   size_t i;
13164
13165   insn_error = NULL;
13166
13167   forced_insn_length = 0;
13168
13169   for (s = str; ISLOWER (*s); ++s)
13170     ;
13171   switch (*s)
13172     {
13173     case '\0':
13174       break;
13175
13176     case ' ':
13177       *s++ = '\0';
13178       break;
13179
13180     case '.':
13181       if (s[1] == 't' && s[2] == ' ')
13182         {
13183           *s = '\0';
13184           forced_insn_length = 2;
13185           s += 3;
13186           break;
13187         }
13188       else if (s[1] == 'e' && s[2] == ' ')
13189         {
13190           *s = '\0';
13191           forced_insn_length = 4;
13192           s += 3;
13193           break;
13194         }
13195       /* Fall through.  */
13196     default:
13197       insn_error = _("unknown opcode");
13198       return;
13199     }
13200
13201   if (mips_opts.noautoextend && !forced_insn_length)
13202     forced_insn_length = 2;
13203
13204   if ((insn = (struct mips_opcode *) hash_find (mips16_op_hash, str)) == NULL)
13205     {
13206       insn_error = _("unrecognized opcode");
13207       return;
13208     }
13209
13210   argsstart = s;
13211   for (;;)
13212     {
13213       bfd_boolean ok;
13214
13215       gas_assert (strcmp (insn->name, str) == 0);
13216
13217       ok = is_opcode_valid_16 (insn);
13218       if (! ok)
13219         {
13220           if (insn + 1 < &mips16_opcodes[bfd_mips16_num_opcodes]
13221               && strcmp (insn->name, insn[1].name) == 0)
13222             {
13223               ++insn;
13224               continue;
13225             }
13226           else
13227             {
13228               if (!insn_error)
13229                 {
13230                   static char buf[100];
13231                   sprintf (buf,
13232                            _("opcode not supported on this processor: %s (%s)"),
13233                            mips_cpu_info_from_arch (mips_opts.arch)->name,
13234                            mips_cpu_info_from_isa (mips_opts.isa)->name);
13235                   insn_error = buf;
13236                 }
13237               return;
13238             }
13239         }
13240
13241       create_insn (ip, insn);
13242       imm_expr.X_op = O_absent;
13243       imm_reloc[0] = BFD_RELOC_UNUSED;
13244       imm_reloc[1] = BFD_RELOC_UNUSED;
13245       imm_reloc[2] = BFD_RELOC_UNUSED;
13246       imm2_expr.X_op = O_absent;
13247       offset_expr.X_op = O_absent;
13248       offset_reloc[0] = BFD_RELOC_UNUSED;
13249       offset_reloc[1] = BFD_RELOC_UNUSED;
13250       offset_reloc[2] = BFD_RELOC_UNUSED;
13251       for (args = insn->args; 1; ++args)
13252         {
13253           int c;
13254
13255           if (*s == ' ')
13256             ++s;
13257
13258           /* In this switch statement we call break if we did not find
13259              a match, continue if we did find a match, or return if we
13260              are done.  */
13261
13262           c = *args;
13263           switch (c)
13264             {
13265             case '\0':
13266               if (*s == '\0')
13267                 {
13268                   /* Stuff the immediate value in now, if we can.  */
13269                   if (imm_expr.X_op == O_constant
13270                       && *imm_reloc > BFD_RELOC_UNUSED
13271                       && *imm_reloc != BFD_RELOC_MIPS16_GOT16
13272                       && *imm_reloc != BFD_RELOC_MIPS16_CALL16
13273                       && insn->pinfo != INSN_MACRO)
13274                     {
13275                       valueT tmp;
13276
13277                       switch (*offset_reloc)
13278                         {
13279                           case BFD_RELOC_MIPS16_HI16_S:
13280                             tmp = (imm_expr.X_add_number + 0x8000) >> 16;
13281                             break;
13282
13283                           case BFD_RELOC_MIPS16_HI16:
13284                             tmp = imm_expr.X_add_number >> 16;
13285                             break;
13286
13287                           case BFD_RELOC_MIPS16_LO16:
13288                             tmp = ((imm_expr.X_add_number + 0x8000) & 0xffff)
13289                                   - 0x8000;
13290                             break;
13291
13292                           case BFD_RELOC_UNUSED:
13293                             tmp = imm_expr.X_add_number;
13294                             break;
13295
13296                           default:
13297                             internalError ();
13298                         }
13299                       *offset_reloc = BFD_RELOC_UNUSED;
13300
13301                       mips16_immed (NULL, 0, *imm_reloc - BFD_RELOC_UNUSED,
13302                                     tmp, TRUE, forced_insn_length == 2,
13303                                     forced_insn_length == 4, &ip->insn_opcode,
13304                                     &ip->use_extend, &ip->extend);
13305                       imm_expr.X_op = O_absent;
13306                       *imm_reloc = BFD_RELOC_UNUSED;
13307                     }
13308
13309                   return;
13310                 }
13311               break;
13312
13313             case ',':
13314               if (*s++ == c)
13315                 continue;
13316               s--;
13317               switch (*++args)
13318                 {
13319                 case 'v':
13320                   MIPS16_INSERT_OPERAND (RX, *ip, lastregno);
13321                   continue;
13322                 case 'w':
13323                   MIPS16_INSERT_OPERAND (RY, *ip, lastregno);
13324                   continue;
13325                 }
13326               break;
13327
13328             case '(':
13329             case ')':
13330               if (*s++ == c)
13331                 continue;
13332               break;
13333
13334             case 'v':
13335             case 'w':
13336               if (s[0] != '$')
13337                 {
13338                   if (c == 'v')
13339                     MIPS16_INSERT_OPERAND (RX, *ip, lastregno);
13340                   else
13341                     MIPS16_INSERT_OPERAND (RY, *ip, lastregno);
13342                   ++args;
13343                   continue;
13344                 }
13345               /* Fall through.  */
13346             case 'x':
13347             case 'y':
13348             case 'z':
13349             case 'Z':
13350             case '0':
13351             case 'S':
13352             case 'R':
13353             case 'X':
13354             case 'Y':
13355               s_reset = s;
13356               if (!reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &regno))
13357                 {
13358                   if (c == 'v' || c == 'w')
13359                     {
13360                       if (c == 'v')
13361                         MIPS16_INSERT_OPERAND (RX, *ip, lastregno);
13362                       else
13363                         MIPS16_INSERT_OPERAND (RY, *ip, lastregno);
13364                       ++args;
13365                       continue;
13366                     }
13367                   break;
13368                 }
13369
13370               if (*s == ' ')
13371                 ++s;
13372               if (args[1] != *s)
13373                 {
13374                   if (c == 'v' || c == 'w')
13375                     {
13376                       regno = mips16_to_32_reg_map[lastregno];
13377                       s = s_reset;
13378                       ++args;
13379                     }
13380                 }
13381
13382               switch (c)
13383                 {
13384                 case 'x':
13385                 case 'y':
13386                 case 'z':
13387                 case 'v':
13388                 case 'w':
13389                 case 'Z':
13390                   regno = mips32_to_16_reg_map[regno];
13391                   break;
13392
13393                 case '0':
13394                   if (regno != 0)
13395                     regno = ILLEGAL_REG;
13396                   break;
13397
13398                 case 'S':
13399                   if (regno != SP)
13400                     regno = ILLEGAL_REG;
13401                   break;
13402
13403                 case 'R':
13404                   if (regno != RA)
13405                     regno = ILLEGAL_REG;
13406                   break;
13407
13408                 case 'X':
13409                 case 'Y':
13410                   if (regno == AT && mips_opts.at)
13411                     {
13412                       if (mips_opts.at == ATREG)
13413                         as_warn (_("used $at without \".set noat\""));
13414                       else
13415                         as_warn (_("used $%u with \".set at=$%u\""),
13416                                  regno, mips_opts.at);
13417                     }
13418                   break;
13419
13420                 default:
13421                   internalError ();
13422                 }
13423
13424               if (regno == ILLEGAL_REG)
13425                 break;
13426
13427               switch (c)
13428                 {
13429                 case 'x':
13430                 case 'v':
13431                   MIPS16_INSERT_OPERAND (RX, *ip, regno);
13432                   break;
13433                 case 'y':
13434                 case 'w':
13435                   MIPS16_INSERT_OPERAND (RY, *ip, regno);
13436                   break;
13437                 case 'z':
13438                   MIPS16_INSERT_OPERAND (RZ, *ip, regno);
13439                   break;
13440                 case 'Z':
13441                   MIPS16_INSERT_OPERAND (MOVE32Z, *ip, regno);
13442                 case '0':
13443                 case 'S':
13444                 case 'R':
13445                   break;
13446                 case 'X':
13447                   MIPS16_INSERT_OPERAND (REGR32, *ip, regno);
13448                   break;
13449                 case 'Y':
13450                   regno = ((regno & 7) << 2) | ((regno & 0x18) >> 3);
13451                   MIPS16_INSERT_OPERAND (REG32R, *ip, regno);
13452                   break;
13453                 default:
13454                   internalError ();
13455                 }
13456
13457               lastregno = regno;
13458               continue;
13459
13460             case 'P':
13461               if (strncmp (s, "$pc", 3) == 0)
13462                 {
13463                   s += 3;
13464                   continue;
13465                 }
13466               break;
13467
13468             case '5':
13469             case 'H':
13470             case 'W':
13471             case 'D':
13472             case 'j':
13473             case 'V':
13474             case 'C':
13475             case 'U':
13476             case 'k':
13477             case 'K':
13478               i = my_getSmallExpression (&imm_expr, imm_reloc, s);
13479               if (i > 0)
13480                 {
13481                   if (imm_expr.X_op != O_constant)
13482                     {
13483                       forced_insn_length = 4;
13484                       ip->use_extend = TRUE;
13485                       ip->extend = 0;
13486                     }
13487                   else
13488                     {
13489                       /* We need to relax this instruction.  */
13490                       *offset_reloc = *imm_reloc;
13491                       *imm_reloc = (int) BFD_RELOC_UNUSED + c;
13492                     }
13493                   s = expr_end;
13494                   continue;
13495                 }
13496               *imm_reloc = BFD_RELOC_UNUSED;
13497               /* Fall through.  */
13498             case '<':
13499             case '>':
13500             case '[':
13501             case ']':
13502             case '4':
13503             case '8':
13504               my_getExpression (&imm_expr, s);
13505               if (imm_expr.X_op == O_register)
13506                 {
13507                   /* What we thought was an expression turned out to
13508                      be a register.  */
13509
13510                   if (s[0] == '(' && args[1] == '(')
13511                     {
13512                       /* It looks like the expression was omitted
13513                          before a register indirection, which means
13514                          that the expression is implicitly zero.  We
13515                          still set up imm_expr, so that we handle
13516                          explicit extensions correctly.  */
13517                       imm_expr.X_op = O_constant;
13518                       imm_expr.X_add_number = 0;
13519                       *imm_reloc = (int) BFD_RELOC_UNUSED + c;
13520                       continue;
13521                     }
13522
13523                   break;
13524                 }
13525
13526               /* We need to relax this instruction.  */
13527               *imm_reloc = (int) BFD_RELOC_UNUSED + c;
13528               s = expr_end;
13529               continue;
13530
13531             case 'p':
13532             case 'q':
13533             case 'A':
13534             case 'B':
13535             case 'E':
13536               /* We use offset_reloc rather than imm_reloc for the PC
13537                  relative operands.  This lets macros with both
13538                  immediate and address operands work correctly.  */
13539               my_getExpression (&offset_expr, s);
13540
13541               if (offset_expr.X_op == O_register)
13542                 break;
13543
13544               /* We need to relax this instruction.  */
13545               *offset_reloc = (int) BFD_RELOC_UNUSED + c;
13546               s = expr_end;
13547               continue;
13548
13549             case '6':           /* break code */
13550               my_getExpression (&imm_expr, s);
13551               check_absolute_expr (ip, &imm_expr);
13552               if ((unsigned long) imm_expr.X_add_number > 63)
13553                 as_warn (_("Invalid value for `%s' (%lu)"),
13554                          ip->insn_mo->name,
13555                          (unsigned long) imm_expr.X_add_number);
13556               MIPS16_INSERT_OPERAND (IMM6, *ip, imm_expr.X_add_number);
13557               imm_expr.X_op = O_absent;
13558               s = expr_end;
13559               continue;
13560
13561             case 'a':           /* 26 bit address */
13562               my_getExpression (&offset_expr, s);
13563               s = expr_end;
13564               *offset_reloc = BFD_RELOC_MIPS16_JMP;
13565               ip->insn_opcode <<= 16;
13566               continue;
13567
13568             case 'l':           /* register list for entry macro */
13569             case 'L':           /* register list for exit macro */
13570               {
13571                 int mask;
13572
13573                 if (c == 'l')
13574                   mask = 0;
13575                 else
13576                   mask = 7 << 3;
13577                 while (*s != '\0')
13578                   {
13579                     unsigned int freg, reg1, reg2;
13580
13581                     while (*s == ' ' || *s == ',')
13582                       ++s;
13583                     if (reg_lookup (&s, RTYPE_GP | RTYPE_NUM, &reg1))
13584                       freg = 0;
13585                     else if (reg_lookup (&s, RTYPE_FPU, &reg1))
13586                       freg = 1;
13587                     else
13588                       {
13589                         as_bad (_("can't parse register list"));
13590                         break;
13591                       }
13592                     if (*s == ' ')
13593                       ++s;
13594                     if (*s != '-')
13595                       reg2 = reg1;
13596                     else
13597                       {
13598                         ++s;
13599                         if (!reg_lookup (&s, freg ? RTYPE_FPU 
13600                                          : (RTYPE_GP | RTYPE_NUM), &reg2))
13601                           {
13602                             as_bad (_("invalid register list"));
13603                             break;
13604                           }
13605                       }
13606                     if (freg && reg1 == 0 && reg2 == 0 && c == 'L')
13607                       {
13608                         mask &= ~ (7 << 3);
13609                         mask |= 5 << 3;
13610                       }
13611                     else if (freg && reg1 == 0 && reg2 == 1 && c == 'L')
13612                       {
13613                         mask &= ~ (7 << 3);
13614                         mask |= 6 << 3;
13615                       }
13616                     else if (reg1 == 4 && reg2 >= 4 && reg2 <= 7 && c != 'L')
13617                       mask |= (reg2 - 3) << 3;
13618                     else if (reg1 == 16 && reg2 >= 16 && reg2 <= 17)
13619                       mask |= (reg2 - 15) << 1;
13620                     else if (reg1 == RA && reg2 == RA)
13621                       mask |= 1;
13622                     else
13623                       {
13624                         as_bad (_("invalid register list"));
13625                         break;
13626                       }
13627                   }
13628                 /* The mask is filled in in the opcode table for the
13629                    benefit of the disassembler.  We remove it before
13630                    applying the actual mask.  */
13631                 ip->insn_opcode &= ~ ((7 << 3) << MIPS16OP_SH_IMM6);
13632                 ip->insn_opcode |= mask << MIPS16OP_SH_IMM6;
13633               }
13634             continue;
13635
13636             case 'm':           /* Register list for save insn.  */
13637             case 'M':           /* Register list for restore insn.  */
13638               {
13639                 int opcode = 0;
13640                 int framesz = 0, seen_framesz = 0;
13641                 int nargs = 0, statics = 0, sregs = 0;
13642
13643                 while (*s != '\0')
13644                   {
13645                     unsigned int reg1, reg2;
13646
13647                     SKIP_SPACE_TABS (s);
13648                     while (*s == ',')
13649                       ++s;
13650                     SKIP_SPACE_TABS (s);
13651
13652                     my_getExpression (&imm_expr, s);
13653                     if (imm_expr.X_op == O_constant)
13654                       {
13655                         /* Handle the frame size.  */
13656                         if (seen_framesz)
13657                           {
13658                             as_bad (_("more than one frame size in list"));
13659                             break;
13660                           }
13661                         seen_framesz = 1;
13662                         framesz = imm_expr.X_add_number;
13663                         imm_expr.X_op = O_absent;
13664                         s = expr_end;
13665                         continue;
13666                       }
13667
13668                     if (! reg_lookup (&s, RTYPE_GP | RTYPE_NUM, &reg1))
13669                       {
13670                         as_bad (_("can't parse register list"));
13671                         break;
13672                       }
13673
13674                     while (*s == ' ')
13675                       ++s;
13676
13677                     if (*s != '-')
13678                       reg2 = reg1;
13679                     else
13680                       {
13681                         ++s;
13682                         if (! reg_lookup (&s, RTYPE_GP | RTYPE_NUM, &reg2)
13683                             || reg2 < reg1)
13684                           {
13685                             as_bad (_("can't parse register list"));
13686                             break;
13687                           }
13688                       }
13689
13690                     while (reg1 <= reg2)
13691                       {
13692                         if (reg1 >= 4 && reg1 <= 7)
13693                           {
13694                             if (!seen_framesz)
13695                                 /* args $a0-$a3 */
13696                                 nargs |= 1 << (reg1 - 4);
13697                             else
13698                                 /* statics $a0-$a3 */
13699                                 statics |= 1 << (reg1 - 4);
13700                           }
13701                         else if ((reg1 >= 16 && reg1 <= 23) || reg1 == 30)
13702                           {
13703                             /* $s0-$s8 */
13704                             sregs |= 1 << ((reg1 == 30) ? 8 : (reg1 - 16));
13705                           }
13706                         else if (reg1 == 31)
13707                           {
13708                             /* Add $ra to insn.  */
13709                             opcode |= 0x40;
13710                           }
13711                         else
13712                           {
13713                             as_bad (_("unexpected register in list"));
13714                             break;
13715                           }
13716                         if (++reg1 == 24)
13717                           reg1 = 30;
13718                       }
13719                   }
13720
13721                 /* Encode args/statics combination.  */
13722                 if (nargs & statics)
13723                   as_bad (_("arg/static registers overlap"));
13724                 else if (nargs == 0xf)
13725                   /* All $a0-$a3 are args.  */
13726                   opcode |= MIPS16_ALL_ARGS << 16;
13727                 else if (statics == 0xf)
13728                   /* All $a0-$a3 are statics.  */
13729                   opcode |= MIPS16_ALL_STATICS << 16;
13730                 else 
13731                   {
13732                     int narg = 0, nstat = 0;
13733
13734                     /* Count arg registers.  */
13735                     while (nargs & 0x1)
13736                       {
13737                         nargs >>= 1;
13738                         narg++;
13739                       }
13740                     if (nargs != 0)
13741                       as_bad (_("invalid arg register list"));
13742
13743                     /* Count static registers.  */
13744                     while (statics & 0x8)
13745                       {
13746                         statics = (statics << 1) & 0xf;
13747                         nstat++;
13748                       }
13749                     if (statics != 0) 
13750                       as_bad (_("invalid static register list"));
13751
13752                     /* Encode args/statics.  */
13753                     opcode |= ((narg << 2) | nstat) << 16;
13754                   }
13755
13756                 /* Encode $s0/$s1.  */
13757                 if (sregs & (1 << 0))           /* $s0 */
13758                   opcode |= 0x20;
13759                 if (sregs & (1 << 1))           /* $s1 */
13760                   opcode |= 0x10;
13761                 sregs >>= 2;
13762
13763                 if (sregs != 0)
13764                   {
13765                     /* Count regs $s2-$s8.  */
13766                     int nsreg = 0;
13767                     while (sregs & 1)
13768                       {
13769                         sregs >>= 1;
13770                         nsreg++;
13771                       }
13772                     if (sregs != 0)
13773                       as_bad (_("invalid static register list"));
13774                     /* Encode $s2-$s8. */
13775                     opcode |= nsreg << 24;
13776                   }
13777
13778                 /* Encode frame size.  */
13779                 if (!seen_framesz)
13780                   as_bad (_("missing frame size"));
13781                 else if ((framesz & 7) != 0 || framesz < 0
13782                          || framesz > 0xff * 8)
13783                   as_bad (_("invalid frame size"));
13784                 else if (framesz != 128 || (opcode >> 16) != 0)
13785                   {
13786                     framesz /= 8;
13787                     opcode |= (((framesz & 0xf0) << 16)
13788                              | (framesz & 0x0f));
13789                   }
13790
13791                 /* Finally build the instruction.  */
13792                 if ((opcode >> 16) != 0 || framesz == 0)
13793                   {
13794                     ip->use_extend = TRUE;
13795                     ip->extend = opcode >> 16;
13796                   }
13797                 ip->insn_opcode |= opcode & 0x7f;
13798               }
13799             continue;
13800
13801             case 'e':           /* extend code */
13802               my_getExpression (&imm_expr, s);
13803               check_absolute_expr (ip, &imm_expr);
13804               if ((unsigned long) imm_expr.X_add_number > 0x7ff)
13805                 {
13806                   as_warn (_("Invalid value for `%s' (%lu)"),
13807                            ip->insn_mo->name,
13808                            (unsigned long) imm_expr.X_add_number);
13809                   imm_expr.X_add_number &= 0x7ff;
13810                 }
13811               ip->insn_opcode |= imm_expr.X_add_number;
13812               imm_expr.X_op = O_absent;
13813               s = expr_end;
13814               continue;
13815
13816             default:
13817               internalError ();
13818             }
13819           break;
13820         }
13821
13822       /* Args don't match.  */
13823       if (insn + 1 < &mips16_opcodes[bfd_mips16_num_opcodes] &&
13824           strcmp (insn->name, insn[1].name) == 0)
13825         {
13826           ++insn;
13827           s = argsstart;
13828           continue;
13829         }
13830
13831       insn_error = _("illegal operands");
13832
13833       return;
13834     }
13835 }
13836
13837 /* This structure holds information we know about a mips16 immediate
13838    argument type.  */
13839
13840 struct mips16_immed_operand
13841 {
13842   /* The type code used in the argument string in the opcode table.  */
13843   int type;
13844   /* The number of bits in the short form of the opcode.  */
13845   int nbits;
13846   /* The number of bits in the extended form of the opcode.  */
13847   int extbits;
13848   /* The amount by which the short form is shifted when it is used;
13849      for example, the sw instruction has a shift count of 2.  */
13850   int shift;
13851   /* The amount by which the short form is shifted when it is stored
13852      into the instruction code.  */
13853   int op_shift;
13854   /* Non-zero if the short form is unsigned.  */
13855   int unsp;
13856   /* Non-zero if the extended form is unsigned.  */
13857   int extu;
13858   /* Non-zero if the value is PC relative.  */
13859   int pcrel;
13860 };
13861
13862 /* The mips16 immediate operand types.  */
13863
13864 static const struct mips16_immed_operand mips16_immed_operands[] =
13865 {
13866   { '<',  3,  5, 0, MIPS16OP_SH_RZ,   1, 1, 0 },
13867   { '>',  3,  5, 0, MIPS16OP_SH_RX,   1, 1, 0 },
13868   { '[',  3,  6, 0, MIPS16OP_SH_RZ,   1, 1, 0 },
13869   { ']',  3,  6, 0, MIPS16OP_SH_RX,   1, 1, 0 },
13870   { '4',  4, 15, 0, MIPS16OP_SH_IMM4, 0, 0, 0 },
13871   { '5',  5, 16, 0, MIPS16OP_SH_IMM5, 1, 0, 0 },
13872   { 'H',  5, 16, 1, MIPS16OP_SH_IMM5, 1, 0, 0 },
13873   { 'W',  5, 16, 2, MIPS16OP_SH_IMM5, 1, 0, 0 },
13874   { 'D',  5, 16, 3, MIPS16OP_SH_IMM5, 1, 0, 0 },
13875   { 'j',  5, 16, 0, MIPS16OP_SH_IMM5, 0, 0, 0 },
13876   { '8',  8, 16, 0, MIPS16OP_SH_IMM8, 1, 0, 0 },
13877   { 'V',  8, 16, 2, MIPS16OP_SH_IMM8, 1, 0, 0 },
13878   { 'C',  8, 16, 3, MIPS16OP_SH_IMM8, 1, 0, 0 },
13879   { 'U',  8, 16, 0, MIPS16OP_SH_IMM8, 1, 1, 0 },
13880   { 'k',  8, 16, 0, MIPS16OP_SH_IMM8, 0, 0, 0 },
13881   { 'K',  8, 16, 3, MIPS16OP_SH_IMM8, 0, 0, 0 },
13882   { 'p',  8, 16, 0, MIPS16OP_SH_IMM8, 0, 0, 1 },
13883   { 'q', 11, 16, 0, MIPS16OP_SH_IMM8, 0, 0, 1 },
13884   { 'A',  8, 16, 2, MIPS16OP_SH_IMM8, 1, 0, 1 },
13885   { 'B',  5, 16, 3, MIPS16OP_SH_IMM5, 1, 0, 1 },
13886   { 'E',  5, 16, 2, MIPS16OP_SH_IMM5, 1, 0, 1 }
13887 };
13888
13889 #define MIPS16_NUM_IMMED \
13890   (sizeof mips16_immed_operands / sizeof mips16_immed_operands[0])
13891
13892 /* Handle a mips16 instruction with an immediate value.  This or's the
13893    small immediate value into *INSN.  It sets *USE_EXTEND to indicate
13894    whether an extended value is needed; if one is needed, it sets
13895    *EXTEND to the value.  The argument type is TYPE.  The value is VAL.
13896    If SMALL is true, an unextended opcode was explicitly requested.
13897    If EXT is true, an extended opcode was explicitly requested.  If
13898    WARN is true, warn if EXT does not match reality.  */
13899
13900 static void
13901 mips16_immed (char *file, unsigned int line, int type, offsetT val,
13902               bfd_boolean warn, bfd_boolean small, bfd_boolean ext,
13903               unsigned long *insn, bfd_boolean *use_extend,
13904               unsigned short *extend)
13905 {
13906   const struct mips16_immed_operand *op;
13907   int mintiny, maxtiny;
13908   bfd_boolean needext;
13909
13910   op = mips16_immed_operands;
13911   while (op->type != type)
13912     {
13913       ++op;
13914       gas_assert (op < mips16_immed_operands + MIPS16_NUM_IMMED);
13915     }
13916
13917   if (op->unsp)
13918     {
13919       if (type == '<' || type == '>' || type == '[' || type == ']')
13920         {
13921           mintiny = 1;
13922           maxtiny = 1 << op->nbits;
13923         }
13924       else
13925         {
13926           mintiny = 0;
13927           maxtiny = (1 << op->nbits) - 1;
13928         }
13929     }
13930   else
13931     {
13932       mintiny = - (1 << (op->nbits - 1));
13933       maxtiny = (1 << (op->nbits - 1)) - 1;
13934     }
13935
13936   /* Branch offsets have an implicit 0 in the lowest bit.  */
13937   if (type == 'p' || type == 'q')
13938     val /= 2;
13939
13940   if ((val & ((1 << op->shift) - 1)) != 0
13941       || val < (mintiny << op->shift)
13942       || val > (maxtiny << op->shift))
13943     needext = TRUE;
13944   else
13945     needext = FALSE;
13946
13947   if (warn && ext && ! needext)
13948     as_warn_where (file, line,
13949                    _("extended operand requested but not required"));
13950   if (small && needext)
13951     as_bad_where (file, line, _("invalid unextended operand value"));
13952
13953   if (small || (! ext && ! needext))
13954     {
13955       int insnval;
13956
13957       *use_extend = FALSE;
13958       insnval = ((val >> op->shift) & ((1 << op->nbits) - 1));
13959       insnval <<= op->op_shift;
13960       *insn |= insnval;
13961     }
13962   else
13963     {
13964       long minext, maxext;
13965       int extval;
13966
13967       if (op->extu)
13968         {
13969           minext = 0;
13970           maxext = (1 << op->extbits) - 1;
13971         }
13972       else
13973         {
13974           minext = - (1 << (op->extbits - 1));
13975           maxext = (1 << (op->extbits - 1)) - 1;
13976         }
13977       if (val < minext || val > maxext)
13978         as_bad_where (file, line,
13979                       _("operand value out of range for instruction"));
13980
13981       *use_extend = TRUE;
13982       if (op->extbits == 16)
13983         {
13984           extval = ((val >> 11) & 0x1f) | (val & 0x7e0);
13985           val &= 0x1f;
13986         }
13987       else if (op->extbits == 15)
13988         {
13989           extval = ((val >> 11) & 0xf) | (val & 0x7f0);
13990           val &= 0xf;
13991         }
13992       else
13993         {
13994           extval = ((val & 0x1f) << 6) | (val & 0x20);
13995           val = 0;
13996         }
13997
13998       *extend = (unsigned short) extval;
13999       *insn |= val;
14000     }
14001 }
14002 \f
14003 struct percent_op_match
14004 {
14005   const char *str;
14006   bfd_reloc_code_real_type reloc;
14007 };
14008
14009 static const struct percent_op_match mips_percent_op[] =
14010 {
14011   {"%lo", BFD_RELOC_LO16},
14012 #ifdef OBJ_ELF
14013   {"%call_hi", BFD_RELOC_MIPS_CALL_HI16},
14014   {"%call_lo", BFD_RELOC_MIPS_CALL_LO16},
14015   {"%call16", BFD_RELOC_MIPS_CALL16},
14016   {"%got_disp", BFD_RELOC_MIPS_GOT_DISP},
14017   {"%got_page", BFD_RELOC_MIPS_GOT_PAGE},
14018   {"%got_ofst", BFD_RELOC_MIPS_GOT_OFST},
14019   {"%got_hi", BFD_RELOC_MIPS_GOT_HI16},
14020   {"%got_lo", BFD_RELOC_MIPS_GOT_LO16},
14021   {"%got", BFD_RELOC_MIPS_GOT16},
14022   {"%gp_rel", BFD_RELOC_GPREL16},
14023   {"%half", BFD_RELOC_16},
14024   {"%highest", BFD_RELOC_MIPS_HIGHEST},
14025   {"%higher", BFD_RELOC_MIPS_HIGHER},
14026   {"%neg", BFD_RELOC_MIPS_SUB},
14027   {"%tlsgd", BFD_RELOC_MIPS_TLS_GD},
14028   {"%tlsldm", BFD_RELOC_MIPS_TLS_LDM},
14029   {"%dtprel_hi", BFD_RELOC_MIPS_TLS_DTPREL_HI16},
14030   {"%dtprel_lo", BFD_RELOC_MIPS_TLS_DTPREL_LO16},
14031   {"%tprel_hi", BFD_RELOC_MIPS_TLS_TPREL_HI16},
14032   {"%tprel_lo", BFD_RELOC_MIPS_TLS_TPREL_LO16},
14033   {"%gottprel", BFD_RELOC_MIPS_TLS_GOTTPREL},
14034 #endif
14035   {"%hi", BFD_RELOC_HI16_S}
14036 };
14037
14038 static const struct percent_op_match mips16_percent_op[] =
14039 {
14040   {"%lo", BFD_RELOC_MIPS16_LO16},
14041   {"%gprel", BFD_RELOC_MIPS16_GPREL},
14042   {"%got", BFD_RELOC_MIPS16_GOT16},
14043   {"%call16", BFD_RELOC_MIPS16_CALL16},
14044   {"%hi", BFD_RELOC_MIPS16_HI16_S}
14045 };
14046
14047
14048 /* Return true if *STR points to a relocation operator.  When returning true,
14049    move *STR over the operator and store its relocation code in *RELOC.
14050    Leave both *STR and *RELOC alone when returning false.  */
14051
14052 static bfd_boolean
14053 parse_relocation (char **str, bfd_reloc_code_real_type *reloc)
14054 {
14055   const struct percent_op_match *percent_op;
14056   size_t limit, i;
14057
14058   if (mips_opts.mips16)
14059     {
14060       percent_op = mips16_percent_op;
14061       limit = ARRAY_SIZE (mips16_percent_op);
14062     }
14063   else
14064     {
14065       percent_op = mips_percent_op;
14066       limit = ARRAY_SIZE (mips_percent_op);
14067     }
14068
14069   for (i = 0; i < limit; i++)
14070     if (strncasecmp (*str, percent_op[i].str, strlen (percent_op[i].str)) == 0)
14071       {
14072         int len = strlen (percent_op[i].str);
14073
14074         if (!ISSPACE ((*str)[len]) && (*str)[len] != '(')
14075           continue;
14076
14077         *str += strlen (percent_op[i].str);
14078         *reloc = percent_op[i].reloc;
14079
14080         /* Check whether the output BFD supports this relocation.
14081            If not, issue an error and fall back on something safe.  */
14082         if (!bfd_reloc_type_lookup (stdoutput, percent_op[i].reloc))
14083           {
14084             as_bad (_("relocation %s isn't supported by the current ABI"),
14085                     percent_op[i].str);
14086             *reloc = BFD_RELOC_UNUSED;
14087           }
14088         return TRUE;
14089       }
14090   return FALSE;
14091 }
14092
14093
14094 /* Parse string STR as a 16-bit relocatable operand.  Store the
14095    expression in *EP and the relocations in the array starting
14096    at RELOC.  Return the number of relocation operators used.
14097
14098    On exit, EXPR_END points to the first character after the expression.  */
14099
14100 static size_t
14101 my_getSmallExpression (expressionS *ep, bfd_reloc_code_real_type *reloc,
14102                        char *str)
14103 {
14104   bfd_reloc_code_real_type reversed_reloc[3];
14105   size_t reloc_index, i;
14106   int crux_depth, str_depth;
14107   char *crux;
14108
14109   /* Search for the start of the main expression, recoding relocations
14110      in REVERSED_RELOC.  End the loop with CRUX pointing to the start
14111      of the main expression and with CRUX_DEPTH containing the number
14112      of open brackets at that point.  */
14113   reloc_index = -1;
14114   str_depth = 0;
14115   do
14116     {
14117       reloc_index++;
14118       crux = str;
14119       crux_depth = str_depth;
14120
14121       /* Skip over whitespace and brackets, keeping count of the number
14122          of brackets.  */
14123       while (*str == ' ' || *str == '\t' || *str == '(')
14124         if (*str++ == '(')
14125           str_depth++;
14126     }
14127   while (*str == '%'
14128          && reloc_index < (HAVE_NEWABI ? 3 : 1)
14129          && parse_relocation (&str, &reversed_reloc[reloc_index]));
14130
14131   my_getExpression (ep, crux);
14132   str = expr_end;
14133
14134   /* Match every open bracket.  */
14135   while (crux_depth > 0 && (*str == ')' || *str == ' ' || *str == '\t'))
14136     if (*str++ == ')')
14137       crux_depth--;
14138
14139   if (crux_depth > 0)
14140     as_bad (_("unclosed '('"));
14141
14142   expr_end = str;
14143
14144   if (reloc_index != 0)
14145     {
14146       prev_reloc_op_frag = frag_now;
14147       for (i = 0; i < reloc_index; i++)
14148         reloc[i] = reversed_reloc[reloc_index - 1 - i];
14149     }
14150
14151   return reloc_index;
14152 }
14153
14154 static void
14155 my_getExpression (expressionS *ep, char *str)
14156 {
14157   char *save_in;
14158
14159   save_in = input_line_pointer;
14160   input_line_pointer = str;
14161   expression (ep);
14162   expr_end = input_line_pointer;
14163   input_line_pointer = save_in;
14164 }
14165
14166 char *
14167 md_atof (int type, char *litP, int *sizeP)
14168 {
14169   return ieee_md_atof (type, litP, sizeP, target_big_endian);
14170 }
14171
14172 void
14173 md_number_to_chars (char *buf, valueT val, int n)
14174 {
14175   if (target_big_endian)
14176     number_to_chars_bigendian (buf, val, n);
14177   else
14178     number_to_chars_littleendian (buf, val, n);
14179 }
14180 \f
14181 #ifdef OBJ_ELF
14182 static int support_64bit_objects(void)
14183 {
14184   const char **list, **l;
14185   int yes;
14186
14187   list = bfd_target_list ();
14188   for (l = list; *l != NULL; l++)
14189     if (strcmp (*l, ELF_TARGET ("elf64-", "big")) == 0
14190         || strcmp (*l, ELF_TARGET ("elf64-", "little")) == 0)
14191       break;
14192   yes = (*l != NULL);
14193   free (list);
14194   return yes;
14195 }
14196 #endif /* OBJ_ELF */
14197
14198 const char *md_shortopts = "O::g::G:";
14199
14200 enum options
14201   {
14202     OPTION_MARCH = OPTION_MD_BASE,
14203     OPTION_MTUNE,
14204     OPTION_MIPS1,
14205     OPTION_MIPS2,
14206     OPTION_MIPS3,
14207     OPTION_MIPS4,
14208     OPTION_MIPS5,
14209     OPTION_MIPS32,
14210     OPTION_MIPS64,
14211     OPTION_MIPS32R2,
14212     OPTION_MIPS64R2,
14213     OPTION_MIPS16,
14214     OPTION_NO_MIPS16,
14215     OPTION_MIPS3D,
14216     OPTION_NO_MIPS3D,
14217     OPTION_MDMX,
14218     OPTION_NO_MDMX,
14219     OPTION_DSP,
14220     OPTION_NO_DSP,
14221     OPTION_MT,
14222     OPTION_NO_MT,
14223     OPTION_SMARTMIPS,
14224     OPTION_NO_SMARTMIPS,
14225     OPTION_DSPR2,
14226     OPTION_NO_DSPR2,
14227     OPTION_MICROMIPS,
14228     OPTION_NO_MICROMIPS,
14229     OPTION_MCU,
14230     OPTION_NO_MCU,
14231     OPTION_COMPAT_ARCH_BASE,
14232     OPTION_M4650,
14233     OPTION_NO_M4650,
14234     OPTION_M4010,
14235     OPTION_NO_M4010,
14236     OPTION_M4100,
14237     OPTION_NO_M4100,
14238     OPTION_M3900,
14239     OPTION_NO_M3900,
14240     OPTION_M7000_HILO_FIX,
14241     OPTION_MNO_7000_HILO_FIX, 
14242     OPTION_FIX_24K,
14243     OPTION_NO_FIX_24K,
14244     OPTION_FIX_LOONGSON2F_JUMP,
14245     OPTION_NO_FIX_LOONGSON2F_JUMP,
14246     OPTION_FIX_LOONGSON2F_NOP,
14247     OPTION_NO_FIX_LOONGSON2F_NOP,
14248     OPTION_FIX_VR4120,
14249     OPTION_NO_FIX_VR4120,
14250     OPTION_FIX_VR4130,
14251     OPTION_NO_FIX_VR4130,
14252     OPTION_FIX_CN63XXP1,
14253     OPTION_NO_FIX_CN63XXP1,
14254     OPTION_TRAP,
14255     OPTION_BREAK,
14256     OPTION_EB,
14257     OPTION_EL,
14258     OPTION_FP32,
14259     OPTION_GP32,
14260     OPTION_CONSTRUCT_FLOATS,
14261     OPTION_NO_CONSTRUCT_FLOATS,
14262     OPTION_FP64,
14263     OPTION_GP64,
14264     OPTION_RELAX_BRANCH,
14265     OPTION_NO_RELAX_BRANCH,
14266     OPTION_MSHARED,
14267     OPTION_MNO_SHARED,
14268     OPTION_MSYM32,
14269     OPTION_MNO_SYM32,
14270     OPTION_SOFT_FLOAT,
14271     OPTION_HARD_FLOAT,
14272     OPTION_SINGLE_FLOAT,
14273     OPTION_DOUBLE_FLOAT,
14274     OPTION_32,
14275 #ifdef OBJ_ELF
14276     OPTION_CALL_SHARED,
14277     OPTION_CALL_NONPIC,
14278     OPTION_NON_SHARED,
14279     OPTION_XGOT,
14280     OPTION_MABI,
14281     OPTION_N32,
14282     OPTION_64,
14283     OPTION_MDEBUG,
14284     OPTION_NO_MDEBUG,
14285     OPTION_PDR,
14286     OPTION_NO_PDR,
14287     OPTION_MVXWORKS_PIC,
14288 #endif /* OBJ_ELF */
14289     OPTION_END_OF_ENUM    
14290   };
14291   
14292 struct option md_longopts[] =
14293 {
14294   /* Options which specify architecture.  */
14295   {"march", required_argument, NULL, OPTION_MARCH},
14296   {"mtune", required_argument, NULL, OPTION_MTUNE},
14297   {"mips0", no_argument, NULL, OPTION_MIPS1},
14298   {"mips1", no_argument, NULL, OPTION_MIPS1},
14299   {"mips2", no_argument, NULL, OPTION_MIPS2},
14300   {"mips3", no_argument, NULL, OPTION_MIPS3},
14301   {"mips4", no_argument, NULL, OPTION_MIPS4},
14302   {"mips5", no_argument, NULL, OPTION_MIPS5},
14303   {"mips32", no_argument, NULL, OPTION_MIPS32},
14304   {"mips64", no_argument, NULL, OPTION_MIPS64},
14305   {"mips32r2", no_argument, NULL, OPTION_MIPS32R2},
14306   {"mips64r2", no_argument, NULL, OPTION_MIPS64R2},
14307
14308   /* Options which specify Application Specific Extensions (ASEs).  */
14309   {"mips16", no_argument, NULL, OPTION_MIPS16},
14310   {"no-mips16", no_argument, NULL, OPTION_NO_MIPS16},
14311   {"mips3d", no_argument, NULL, OPTION_MIPS3D},
14312   {"no-mips3d", no_argument, NULL, OPTION_NO_MIPS3D},
14313   {"mdmx", no_argument, NULL, OPTION_MDMX},
14314   {"no-mdmx", no_argument, NULL, OPTION_NO_MDMX},
14315   {"mdsp", no_argument, NULL, OPTION_DSP},
14316   {"mno-dsp", no_argument, NULL, OPTION_NO_DSP},
14317   {"mmt", no_argument, NULL, OPTION_MT},
14318   {"mno-mt", no_argument, NULL, OPTION_NO_MT},
14319   {"msmartmips", no_argument, NULL, OPTION_SMARTMIPS},
14320   {"mno-smartmips", no_argument, NULL, OPTION_NO_SMARTMIPS},
14321   {"mdspr2", no_argument, NULL, OPTION_DSPR2},
14322   {"mno-dspr2", no_argument, NULL, OPTION_NO_DSPR2},
14323   {"mmicromips", no_argument, NULL, OPTION_MICROMIPS},
14324   {"mno-micromips", no_argument, NULL, OPTION_NO_MICROMIPS},
14325   {"mmcu", no_argument, NULL, OPTION_MCU},
14326   {"mno-mcu", no_argument, NULL, OPTION_NO_MCU},
14327
14328   /* Old-style architecture options.  Don't add more of these.  */
14329   {"m4650", no_argument, NULL, OPTION_M4650},
14330   {"no-m4650", no_argument, NULL, OPTION_NO_M4650},
14331   {"m4010", no_argument, NULL, OPTION_M4010},
14332   {"no-m4010", no_argument, NULL, OPTION_NO_M4010},
14333   {"m4100", no_argument, NULL, OPTION_M4100},
14334   {"no-m4100", no_argument, NULL, OPTION_NO_M4100},
14335   {"m3900", no_argument, NULL, OPTION_M3900},
14336   {"no-m3900", no_argument, NULL, OPTION_NO_M3900},
14337
14338   /* Options which enable bug fixes.  */
14339   {"mfix7000", no_argument, NULL, OPTION_M7000_HILO_FIX},
14340   {"no-fix-7000", no_argument, NULL, OPTION_MNO_7000_HILO_FIX},
14341   {"mno-fix7000", no_argument, NULL, OPTION_MNO_7000_HILO_FIX},
14342   {"mfix-loongson2f-jump", no_argument, NULL, OPTION_FIX_LOONGSON2F_JUMP},
14343   {"mno-fix-loongson2f-jump", no_argument, NULL, OPTION_NO_FIX_LOONGSON2F_JUMP},
14344   {"mfix-loongson2f-nop", no_argument, NULL, OPTION_FIX_LOONGSON2F_NOP},
14345   {"mno-fix-loongson2f-nop", no_argument, NULL, OPTION_NO_FIX_LOONGSON2F_NOP},
14346   {"mfix-vr4120",    no_argument, NULL, OPTION_FIX_VR4120},
14347   {"mno-fix-vr4120", no_argument, NULL, OPTION_NO_FIX_VR4120},
14348   {"mfix-vr4130",    no_argument, NULL, OPTION_FIX_VR4130},
14349   {"mno-fix-vr4130", no_argument, NULL, OPTION_NO_FIX_VR4130},
14350   {"mfix-24k",    no_argument, NULL, OPTION_FIX_24K},
14351   {"mno-fix-24k", no_argument, NULL, OPTION_NO_FIX_24K},
14352   {"mfix-cn63xxp1", no_argument, NULL, OPTION_FIX_CN63XXP1},
14353   {"mno-fix-cn63xxp1", no_argument, NULL, OPTION_NO_FIX_CN63XXP1},
14354
14355   /* Miscellaneous options.  */
14356   {"trap", no_argument, NULL, OPTION_TRAP},
14357   {"no-break", no_argument, NULL, OPTION_TRAP},
14358   {"break", no_argument, NULL, OPTION_BREAK},
14359   {"no-trap", no_argument, NULL, OPTION_BREAK},
14360   {"EB", no_argument, NULL, OPTION_EB},
14361   {"EL", no_argument, NULL, OPTION_EL},
14362   {"mfp32", no_argument, NULL, OPTION_FP32},
14363   {"mgp32", no_argument, NULL, OPTION_GP32},
14364   {"construct-floats", no_argument, NULL, OPTION_CONSTRUCT_FLOATS},
14365   {"no-construct-floats", no_argument, NULL, OPTION_NO_CONSTRUCT_FLOATS},
14366   {"mfp64", no_argument, NULL, OPTION_FP64},
14367   {"mgp64", no_argument, NULL, OPTION_GP64},
14368   {"relax-branch", no_argument, NULL, OPTION_RELAX_BRANCH},
14369   {"no-relax-branch", no_argument, NULL, OPTION_NO_RELAX_BRANCH},
14370   {"mshared", no_argument, NULL, OPTION_MSHARED},
14371   {"mno-shared", no_argument, NULL, OPTION_MNO_SHARED},
14372   {"msym32", no_argument, NULL, OPTION_MSYM32},
14373   {"mno-sym32", no_argument, NULL, OPTION_MNO_SYM32},
14374   {"msoft-float", no_argument, NULL, OPTION_SOFT_FLOAT},
14375   {"mhard-float", no_argument, NULL, OPTION_HARD_FLOAT},
14376   {"msingle-float", no_argument, NULL, OPTION_SINGLE_FLOAT},
14377   {"mdouble-float", no_argument, NULL, OPTION_DOUBLE_FLOAT},
14378
14379   /* Strictly speaking this next option is ELF specific,
14380      but we allow it for other ports as well in order to
14381      make testing easier.  */
14382   {"32",          no_argument, NULL, OPTION_32},
14383   
14384   /* ELF-specific options.  */
14385 #ifdef OBJ_ELF
14386   {"KPIC",        no_argument, NULL, OPTION_CALL_SHARED},
14387   {"call_shared", no_argument, NULL, OPTION_CALL_SHARED},
14388   {"call_nonpic", no_argument, NULL, OPTION_CALL_NONPIC},
14389   {"non_shared",  no_argument, NULL, OPTION_NON_SHARED},
14390   {"xgot",        no_argument, NULL, OPTION_XGOT},
14391   {"mabi", required_argument, NULL, OPTION_MABI},
14392   {"n32",         no_argument, NULL, OPTION_N32},
14393   {"64",          no_argument, NULL, OPTION_64},
14394   {"mdebug", no_argument, NULL, OPTION_MDEBUG},
14395   {"no-mdebug", no_argument, NULL, OPTION_NO_MDEBUG},
14396   {"mpdr", no_argument, NULL, OPTION_PDR},
14397   {"mno-pdr", no_argument, NULL, OPTION_NO_PDR},
14398   {"mvxworks-pic", no_argument, NULL, OPTION_MVXWORKS_PIC},
14399 #endif /* OBJ_ELF */
14400
14401   {NULL, no_argument, NULL, 0}
14402 };
14403 size_t md_longopts_size = sizeof (md_longopts);
14404
14405 /* Set STRING_PTR (either &mips_arch_string or &mips_tune_string) to
14406    NEW_VALUE.  Warn if another value was already specified.  Note:
14407    we have to defer parsing the -march and -mtune arguments in order
14408    to handle 'from-abi' correctly, since the ABI might be specified
14409    in a later argument.  */
14410
14411 static void
14412 mips_set_option_string (const char **string_ptr, const char *new_value)
14413 {
14414   if (*string_ptr != 0 && strcasecmp (*string_ptr, new_value) != 0)
14415     as_warn (_("A different %s was already specified, is now %s"),
14416              string_ptr == &mips_arch_string ? "-march" : "-mtune",
14417              new_value);
14418
14419   *string_ptr = new_value;
14420 }
14421
14422 int
14423 md_parse_option (int c, char *arg)
14424 {
14425   switch (c)
14426     {
14427     case OPTION_CONSTRUCT_FLOATS:
14428       mips_disable_float_construction = 0;
14429       break;
14430
14431     case OPTION_NO_CONSTRUCT_FLOATS:
14432       mips_disable_float_construction = 1;
14433       break;
14434
14435     case OPTION_TRAP:
14436       mips_trap = 1;
14437       break;
14438
14439     case OPTION_BREAK:
14440       mips_trap = 0;
14441       break;
14442
14443     case OPTION_EB:
14444       target_big_endian = 1;
14445       break;
14446
14447     case OPTION_EL:
14448       target_big_endian = 0;
14449       break;
14450
14451     case 'O':
14452       if (arg == NULL)
14453         mips_optimize = 1;
14454       else if (arg[0] == '0')
14455         mips_optimize = 0;
14456       else if (arg[0] == '1')
14457         mips_optimize = 1;
14458       else
14459         mips_optimize = 2;
14460       break;
14461
14462     case 'g':
14463       if (arg == NULL)
14464         mips_debug = 2;
14465       else
14466         mips_debug = atoi (arg);
14467       break;
14468
14469     case OPTION_MIPS1:
14470       file_mips_isa = ISA_MIPS1;
14471       break;
14472
14473     case OPTION_MIPS2:
14474       file_mips_isa = ISA_MIPS2;
14475       break;
14476
14477     case OPTION_MIPS3:
14478       file_mips_isa = ISA_MIPS3;
14479       break;
14480
14481     case OPTION_MIPS4:
14482       file_mips_isa = ISA_MIPS4;
14483       break;
14484
14485     case OPTION_MIPS5:
14486       file_mips_isa = ISA_MIPS5;
14487       break;
14488
14489     case OPTION_MIPS32:
14490       file_mips_isa = ISA_MIPS32;
14491       break;
14492
14493     case OPTION_MIPS32R2:
14494       file_mips_isa = ISA_MIPS32R2;
14495       break;
14496
14497     case OPTION_MIPS64R2:
14498       file_mips_isa = ISA_MIPS64R2;
14499       break;
14500
14501     case OPTION_MIPS64:
14502       file_mips_isa = ISA_MIPS64;
14503       break;
14504
14505     case OPTION_MTUNE:
14506       mips_set_option_string (&mips_tune_string, arg);
14507       break;
14508
14509     case OPTION_MARCH:
14510       mips_set_option_string (&mips_arch_string, arg);
14511       break;
14512
14513     case OPTION_M4650:
14514       mips_set_option_string (&mips_arch_string, "4650");
14515       mips_set_option_string (&mips_tune_string, "4650");
14516       break;
14517
14518     case OPTION_NO_M4650:
14519       break;
14520
14521     case OPTION_M4010:
14522       mips_set_option_string (&mips_arch_string, "4010");
14523       mips_set_option_string (&mips_tune_string, "4010");
14524       break;
14525
14526     case OPTION_NO_M4010:
14527       break;
14528
14529     case OPTION_M4100:
14530       mips_set_option_string (&mips_arch_string, "4100");
14531       mips_set_option_string (&mips_tune_string, "4100");
14532       break;
14533
14534     case OPTION_NO_M4100:
14535       break;
14536
14537     case OPTION_M3900:
14538       mips_set_option_string (&mips_arch_string, "3900");
14539       mips_set_option_string (&mips_tune_string, "3900");
14540       break;
14541
14542     case OPTION_NO_M3900:
14543       break;
14544
14545     case OPTION_MDMX:
14546       mips_opts.ase_mdmx = 1;
14547       break;
14548
14549     case OPTION_NO_MDMX:
14550       mips_opts.ase_mdmx = 0;
14551       break;
14552
14553     case OPTION_DSP:
14554       mips_opts.ase_dsp = 1;
14555       mips_opts.ase_dspr2 = 0;
14556       break;
14557
14558     case OPTION_NO_DSP:
14559       mips_opts.ase_dsp = 0;
14560       mips_opts.ase_dspr2 = 0;
14561       break;
14562
14563     case OPTION_DSPR2:
14564       mips_opts.ase_dspr2 = 1;
14565       mips_opts.ase_dsp = 1;
14566       break;
14567
14568     case OPTION_NO_DSPR2:
14569       mips_opts.ase_dspr2 = 0;
14570       mips_opts.ase_dsp = 0;
14571       break;
14572
14573     case OPTION_MT:
14574       mips_opts.ase_mt = 1;
14575       break;
14576
14577     case OPTION_NO_MT:
14578       mips_opts.ase_mt = 0;
14579       break;
14580
14581     case OPTION_MCU:
14582       mips_opts.ase_mcu = 1;
14583       break;
14584
14585     case OPTION_NO_MCU:
14586       mips_opts.ase_mcu = 0;
14587       break;
14588
14589     case OPTION_MICROMIPS:
14590       if (mips_opts.mips16 == 1)
14591         {
14592           as_bad (_("-mmicromips cannot be used with -mips16"));
14593           return 0;
14594         }
14595       mips_opts.micromips = 1;
14596       mips_no_prev_insn ();
14597       break;
14598
14599     case OPTION_NO_MICROMIPS:
14600       mips_opts.micromips = 0;
14601       mips_no_prev_insn ();
14602       break;
14603
14604     case OPTION_MIPS16:
14605       if (mips_opts.micromips == 1)
14606         {
14607           as_bad (_("-mips16 cannot be used with -micromips"));
14608           return 0;
14609         }
14610       mips_opts.mips16 = 1;
14611       mips_no_prev_insn ();
14612       break;
14613
14614     case OPTION_NO_MIPS16:
14615       mips_opts.mips16 = 0;
14616       mips_no_prev_insn ();
14617       break;
14618
14619     case OPTION_MIPS3D:
14620       mips_opts.ase_mips3d = 1;
14621       break;
14622
14623     case OPTION_NO_MIPS3D:
14624       mips_opts.ase_mips3d = 0;
14625       break;
14626
14627     case OPTION_SMARTMIPS:
14628       mips_opts.ase_smartmips = 1;
14629       break;
14630
14631     case OPTION_NO_SMARTMIPS:
14632       mips_opts.ase_smartmips = 0;
14633       break;
14634
14635     case OPTION_FIX_24K:
14636       mips_fix_24k = 1;
14637       break;
14638
14639     case OPTION_NO_FIX_24K:
14640       mips_fix_24k = 0;
14641       break;
14642
14643     case OPTION_FIX_LOONGSON2F_JUMP:
14644       mips_fix_loongson2f_jump = TRUE;
14645       break;
14646
14647     case OPTION_NO_FIX_LOONGSON2F_JUMP:
14648       mips_fix_loongson2f_jump = FALSE;
14649       break;
14650
14651     case OPTION_FIX_LOONGSON2F_NOP:
14652       mips_fix_loongson2f_nop = TRUE;
14653       break;
14654
14655     case OPTION_NO_FIX_LOONGSON2F_NOP:
14656       mips_fix_loongson2f_nop = FALSE;
14657       break;
14658
14659     case OPTION_FIX_VR4120:
14660       mips_fix_vr4120 = 1;
14661       break;
14662
14663     case OPTION_NO_FIX_VR4120:
14664       mips_fix_vr4120 = 0;
14665       break;
14666
14667     case OPTION_FIX_VR4130:
14668       mips_fix_vr4130 = 1;
14669       break;
14670
14671     case OPTION_NO_FIX_VR4130:
14672       mips_fix_vr4130 = 0;
14673       break;
14674
14675     case OPTION_FIX_CN63XXP1:
14676       mips_fix_cn63xxp1 = TRUE;
14677       break;
14678
14679     case OPTION_NO_FIX_CN63XXP1:
14680       mips_fix_cn63xxp1 = FALSE;
14681       break;
14682
14683     case OPTION_RELAX_BRANCH:
14684       mips_relax_branch = 1;
14685       break;
14686
14687     case OPTION_NO_RELAX_BRANCH:
14688       mips_relax_branch = 0;
14689       break;
14690
14691     case OPTION_MSHARED:
14692       mips_in_shared = TRUE;
14693       break;
14694
14695     case OPTION_MNO_SHARED:
14696       mips_in_shared = FALSE;
14697       break;
14698
14699     case OPTION_MSYM32:
14700       mips_opts.sym32 = TRUE;
14701       break;
14702
14703     case OPTION_MNO_SYM32:
14704       mips_opts.sym32 = FALSE;
14705       break;
14706
14707 #ifdef OBJ_ELF
14708       /* When generating ELF code, we permit -KPIC and -call_shared to
14709          select SVR4_PIC, and -non_shared to select no PIC.  This is
14710          intended to be compatible with Irix 5.  */
14711     case OPTION_CALL_SHARED:
14712       if (!IS_ELF)
14713         {
14714           as_bad (_("-call_shared is supported only for ELF format"));
14715           return 0;
14716         }
14717       mips_pic = SVR4_PIC;
14718       mips_abicalls = TRUE;
14719       break;
14720
14721     case OPTION_CALL_NONPIC:
14722       if (!IS_ELF)
14723         {
14724           as_bad (_("-call_nonpic is supported only for ELF format"));
14725           return 0;
14726         }
14727       mips_pic = NO_PIC;
14728       mips_abicalls = TRUE;
14729       break;
14730
14731     case OPTION_NON_SHARED:
14732       if (!IS_ELF)
14733         {
14734           as_bad (_("-non_shared is supported only for ELF format"));
14735           return 0;
14736         }
14737       mips_pic = NO_PIC;
14738       mips_abicalls = FALSE;
14739       break;
14740
14741       /* The -xgot option tells the assembler to use 32 bit offsets
14742          when accessing the got in SVR4_PIC mode.  It is for Irix
14743          compatibility.  */
14744     case OPTION_XGOT:
14745       mips_big_got = 1;
14746       break;
14747 #endif /* OBJ_ELF */
14748
14749     case 'G':
14750       g_switch_value = atoi (arg);
14751       g_switch_seen = 1;
14752       break;
14753
14754       /* The -32, -n32 and -64 options are shortcuts for -mabi=32, -mabi=n32
14755          and -mabi=64.  */
14756     case OPTION_32:
14757       if (IS_ELF)
14758         mips_abi = O32_ABI;
14759       /* We silently ignore -32 for non-ELF targets.  This greatly
14760          simplifies the construction of the MIPS GAS test cases.  */
14761       break;
14762
14763 #ifdef OBJ_ELF
14764     case OPTION_N32:
14765       if (!IS_ELF)
14766         {
14767           as_bad (_("-n32 is supported for ELF format only"));
14768           return 0;
14769         }
14770       mips_abi = N32_ABI;
14771       break;
14772
14773     case OPTION_64:
14774       if (!IS_ELF)
14775         {
14776           as_bad (_("-64 is supported for ELF format only"));
14777           return 0;
14778         }
14779       mips_abi = N64_ABI;
14780       if (!support_64bit_objects())
14781         as_fatal (_("No compiled in support for 64 bit object file format"));
14782       break;
14783 #endif /* OBJ_ELF */
14784
14785     case OPTION_GP32:
14786       file_mips_gp32 = 1;
14787       break;
14788
14789     case OPTION_GP64:
14790       file_mips_gp32 = 0;
14791       break;
14792
14793     case OPTION_FP32:
14794       file_mips_fp32 = 1;
14795       break;
14796
14797     case OPTION_FP64:
14798       file_mips_fp32 = 0;
14799       break;
14800
14801     case OPTION_SINGLE_FLOAT:
14802       file_mips_single_float = 1;
14803       break;
14804
14805     case OPTION_DOUBLE_FLOAT:
14806       file_mips_single_float = 0;
14807       break;
14808
14809     case OPTION_SOFT_FLOAT:
14810       file_mips_soft_float = 1;
14811       break;
14812
14813     case OPTION_HARD_FLOAT:
14814       file_mips_soft_float = 0;
14815       break;
14816
14817 #ifdef OBJ_ELF
14818     case OPTION_MABI:
14819       if (!IS_ELF)
14820         {
14821           as_bad (_("-mabi is supported for ELF format only"));
14822           return 0;
14823         }
14824       if (strcmp (arg, "32") == 0)
14825         mips_abi = O32_ABI;
14826       else if (strcmp (arg, "o64") == 0)
14827         mips_abi = O64_ABI;
14828       else if (strcmp (arg, "n32") == 0)
14829         mips_abi = N32_ABI;
14830       else if (strcmp (arg, "64") == 0)
14831         {
14832           mips_abi = N64_ABI;
14833           if (! support_64bit_objects())
14834             as_fatal (_("No compiled in support for 64 bit object file "
14835                         "format"));
14836         }
14837       else if (strcmp (arg, "eabi") == 0)
14838         mips_abi = EABI_ABI;
14839       else
14840         {
14841           as_fatal (_("invalid abi -mabi=%s"), arg);
14842           return 0;
14843         }
14844       break;
14845 #endif /* OBJ_ELF */
14846
14847     case OPTION_M7000_HILO_FIX:
14848       mips_7000_hilo_fix = TRUE;
14849       break;
14850
14851     case OPTION_MNO_7000_HILO_FIX:
14852       mips_7000_hilo_fix = FALSE;
14853       break;
14854
14855 #ifdef OBJ_ELF
14856     case OPTION_MDEBUG:
14857       mips_flag_mdebug = TRUE;
14858       break;
14859
14860     case OPTION_NO_MDEBUG:
14861       mips_flag_mdebug = FALSE;
14862       break;
14863
14864     case OPTION_PDR:
14865       mips_flag_pdr = TRUE;
14866       break;
14867
14868     case OPTION_NO_PDR:
14869       mips_flag_pdr = FALSE;
14870       break;
14871
14872     case OPTION_MVXWORKS_PIC:
14873       mips_pic = VXWORKS_PIC;
14874       break;
14875 #endif /* OBJ_ELF */
14876
14877     default:
14878       return 0;
14879     }
14880
14881     mips_fix_loongson2f = mips_fix_loongson2f_nop || mips_fix_loongson2f_jump;
14882
14883   return 1;
14884 }
14885 \f
14886 /* Set up globals to generate code for the ISA or processor
14887    described by INFO.  */
14888
14889 static void
14890 mips_set_architecture (const struct mips_cpu_info *info)
14891 {
14892   if (info != 0)
14893     {
14894       file_mips_arch = info->cpu;
14895       mips_opts.arch = info->cpu;
14896       mips_opts.isa = info->isa;
14897     }
14898 }
14899
14900
14901 /* Likewise for tuning.  */
14902
14903 static void
14904 mips_set_tune (const struct mips_cpu_info *info)
14905 {
14906   if (info != 0)
14907     mips_tune = info->cpu;
14908 }
14909
14910
14911 void
14912 mips_after_parse_args (void)
14913 {
14914   const struct mips_cpu_info *arch_info = 0;
14915   const struct mips_cpu_info *tune_info = 0;
14916
14917   /* GP relative stuff not working for PE */
14918   if (strncmp (TARGET_OS, "pe", 2) == 0)
14919     {
14920       if (g_switch_seen && g_switch_value != 0)
14921         as_bad (_("-G not supported in this configuration."));
14922       g_switch_value = 0;
14923     }
14924
14925   if (mips_abi == NO_ABI)
14926     mips_abi = MIPS_DEFAULT_ABI;
14927
14928   /* The following code determines the architecture and register size.
14929      Similar code was added to GCC 3.3 (see override_options() in
14930      config/mips/mips.c).  The GAS and GCC code should be kept in sync
14931      as much as possible.  */
14932
14933   if (mips_arch_string != 0)
14934     arch_info = mips_parse_cpu ("-march", mips_arch_string);
14935
14936   if (file_mips_isa != ISA_UNKNOWN)
14937     {
14938       /* Handle -mipsN.  At this point, file_mips_isa contains the
14939          ISA level specified by -mipsN, while arch_info->isa contains
14940          the -march selection (if any).  */
14941       if (arch_info != 0)
14942         {
14943           /* -march takes precedence over -mipsN, since it is more descriptive.
14944              There's no harm in specifying both as long as the ISA levels
14945              are the same.  */
14946           if (file_mips_isa != arch_info->isa)
14947             as_bad (_("-%s conflicts with the other architecture options, which imply -%s"),
14948                     mips_cpu_info_from_isa (file_mips_isa)->name,
14949                     mips_cpu_info_from_isa (arch_info->isa)->name);
14950         }
14951       else
14952         arch_info = mips_cpu_info_from_isa (file_mips_isa);
14953     }
14954
14955   if (arch_info == 0)
14956     arch_info = mips_parse_cpu ("default CPU", MIPS_CPU_STRING_DEFAULT);
14957
14958   if (ABI_NEEDS_64BIT_REGS (mips_abi) && !ISA_HAS_64BIT_REGS (arch_info->isa))
14959     as_bad (_("-march=%s is not compatible with the selected ABI"),
14960             arch_info->name);
14961
14962   mips_set_architecture (arch_info);
14963
14964   /* Optimize for file_mips_arch, unless -mtune selects a different processor.  */
14965   if (mips_tune_string != 0)
14966     tune_info = mips_parse_cpu ("-mtune", mips_tune_string);
14967
14968   if (tune_info == 0)
14969     mips_set_tune (arch_info);
14970   else
14971     mips_set_tune (tune_info);
14972
14973   if (file_mips_gp32 >= 0)
14974     {
14975       /* The user specified the size of the integer registers.  Make sure
14976          it agrees with the ABI and ISA.  */
14977       if (file_mips_gp32 == 0 && !ISA_HAS_64BIT_REGS (mips_opts.isa))
14978         as_bad (_("-mgp64 used with a 32-bit processor"));
14979       else if (file_mips_gp32 == 1 && ABI_NEEDS_64BIT_REGS (mips_abi))
14980         as_bad (_("-mgp32 used with a 64-bit ABI"));
14981       else if (file_mips_gp32 == 0 && ABI_NEEDS_32BIT_REGS (mips_abi))
14982         as_bad (_("-mgp64 used with a 32-bit ABI"));
14983     }
14984   else
14985     {
14986       /* Infer the integer register size from the ABI and processor.
14987          Restrict ourselves to 32-bit registers if that's all the
14988          processor has, or if the ABI cannot handle 64-bit registers.  */
14989       file_mips_gp32 = (ABI_NEEDS_32BIT_REGS (mips_abi)
14990                         || !ISA_HAS_64BIT_REGS (mips_opts.isa));
14991     }
14992
14993   switch (file_mips_fp32)
14994     {
14995     default:
14996     case -1:
14997       /* No user specified float register size.
14998          ??? GAS treats single-float processors as though they had 64-bit
14999          float registers (although it complains when double-precision
15000          instructions are used).  As things stand, saying they have 32-bit
15001          registers would lead to spurious "register must be even" messages.
15002          So here we assume float registers are never smaller than the
15003          integer ones.  */
15004       if (file_mips_gp32 == 0)
15005         /* 64-bit integer registers implies 64-bit float registers.  */
15006         file_mips_fp32 = 0;
15007       else if ((mips_opts.ase_mips3d > 0 || mips_opts.ase_mdmx > 0)
15008                && ISA_HAS_64BIT_FPRS (mips_opts.isa))
15009         /* -mips3d and -mdmx imply 64-bit float registers, if possible.  */
15010         file_mips_fp32 = 0;
15011       else
15012         /* 32-bit float registers.  */
15013         file_mips_fp32 = 1;
15014       break;
15015
15016     /* The user specified the size of the float registers.  Check if it
15017        agrees with the ABI and ISA.  */
15018     case 0:
15019       if (!ISA_HAS_64BIT_FPRS (mips_opts.isa))
15020         as_bad (_("-mfp64 used with a 32-bit fpu"));
15021       else if (ABI_NEEDS_32BIT_REGS (mips_abi)
15022                && !ISA_HAS_MXHC1 (mips_opts.isa))
15023         as_warn (_("-mfp64 used with a 32-bit ABI"));
15024       break;
15025     case 1:
15026       if (ABI_NEEDS_64BIT_REGS (mips_abi))
15027         as_warn (_("-mfp32 used with a 64-bit ABI"));
15028       break;
15029     }
15030
15031   /* End of GCC-shared inference code.  */
15032
15033   /* This flag is set when we have a 64-bit capable CPU but use only
15034      32-bit wide registers.  Note that EABI does not use it.  */
15035   if (ISA_HAS_64BIT_REGS (mips_opts.isa)
15036       && ((mips_abi == NO_ABI && file_mips_gp32 == 1)
15037           || mips_abi == O32_ABI))
15038     mips_32bitmode = 1;
15039
15040   if (mips_opts.isa == ISA_MIPS1 && mips_trap)
15041     as_bad (_("trap exception not supported at ISA 1"));
15042
15043   /* If the selected architecture includes support for ASEs, enable
15044      generation of code for them.  */
15045   if (mips_opts.mips16 == -1)
15046     mips_opts.mips16 = (CPU_HAS_MIPS16 (file_mips_arch)) ? 1 : 0;
15047   if (mips_opts.micromips == -1)
15048     mips_opts.micromips = (CPU_HAS_MICROMIPS (file_mips_arch)) ? 1 : 0;
15049   if (mips_opts.ase_mips3d == -1)
15050     mips_opts.ase_mips3d = ((arch_info->flags & MIPS_CPU_ASE_MIPS3D)
15051                             && file_mips_fp32 == 0) ? 1 : 0;
15052   if (mips_opts.ase_mips3d && file_mips_fp32 == 1)
15053     as_bad (_("-mfp32 used with -mips3d"));
15054
15055   if (mips_opts.ase_mdmx == -1)
15056     mips_opts.ase_mdmx = ((arch_info->flags & MIPS_CPU_ASE_MDMX)
15057                           && file_mips_fp32 == 0) ? 1 : 0;
15058   if (mips_opts.ase_mdmx && file_mips_fp32 == 1)
15059     as_bad (_("-mfp32 used with -mdmx"));
15060
15061   if (mips_opts.ase_smartmips == -1)
15062     mips_opts.ase_smartmips = (arch_info->flags & MIPS_CPU_ASE_SMARTMIPS) ? 1 : 0;
15063   if (mips_opts.ase_smartmips && !ISA_SUPPORTS_SMARTMIPS)
15064     as_warn (_("%s ISA does not support SmartMIPS"), 
15065              mips_cpu_info_from_isa (mips_opts.isa)->name);
15066
15067   if (mips_opts.ase_dsp == -1)
15068     mips_opts.ase_dsp = (arch_info->flags & MIPS_CPU_ASE_DSP) ? 1 : 0;
15069   if (mips_opts.ase_dsp && !ISA_SUPPORTS_DSP_ASE)
15070     as_warn (_("%s ISA does not support DSP ASE"), 
15071              mips_cpu_info_from_isa (mips_opts.isa)->name);
15072
15073   if (mips_opts.ase_dspr2 == -1)
15074     {
15075       mips_opts.ase_dspr2 = (arch_info->flags & MIPS_CPU_ASE_DSPR2) ? 1 : 0;
15076       mips_opts.ase_dsp = (arch_info->flags & MIPS_CPU_ASE_DSP) ? 1 : 0;
15077     }
15078   if (mips_opts.ase_dspr2 && !ISA_SUPPORTS_DSPR2_ASE)
15079     as_warn (_("%s ISA does not support DSP R2 ASE"),
15080              mips_cpu_info_from_isa (mips_opts.isa)->name);
15081
15082   if (mips_opts.ase_mt == -1)
15083     mips_opts.ase_mt = (arch_info->flags & MIPS_CPU_ASE_MT) ? 1 : 0;
15084   if (mips_opts.ase_mt && !ISA_SUPPORTS_MT_ASE)
15085     as_warn (_("%s ISA does not support MT ASE"),
15086              mips_cpu_info_from_isa (mips_opts.isa)->name);
15087
15088   if (mips_opts.ase_mcu == -1)
15089     mips_opts.ase_mcu = (arch_info->flags & MIPS_CPU_ASE_MCU) ? 1 : 0;
15090   if (mips_opts.ase_mcu && !ISA_SUPPORTS_MCU_ASE)
15091       as_warn (_("%s ISA does not support MCU ASE"),
15092                mips_cpu_info_from_isa (mips_opts.isa)->name);
15093
15094   file_mips_isa = mips_opts.isa;
15095   file_ase_mips3d = mips_opts.ase_mips3d;
15096   file_ase_mdmx = mips_opts.ase_mdmx;
15097   file_ase_smartmips = mips_opts.ase_smartmips;
15098   file_ase_dsp = mips_opts.ase_dsp;
15099   file_ase_dspr2 = mips_opts.ase_dspr2;
15100   file_ase_mt = mips_opts.ase_mt;
15101   mips_opts.gp32 = file_mips_gp32;
15102   mips_opts.fp32 = file_mips_fp32;
15103   mips_opts.soft_float = file_mips_soft_float;
15104   mips_opts.single_float = file_mips_single_float;
15105
15106   if (mips_flag_mdebug < 0)
15107     {
15108 #ifdef OBJ_MAYBE_ECOFF
15109       if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour)
15110         mips_flag_mdebug = 1;
15111       else
15112 #endif /* OBJ_MAYBE_ECOFF */
15113         mips_flag_mdebug = 0;
15114     }
15115 }
15116 \f
15117 void
15118 mips_init_after_args (void)
15119 {
15120   /* initialize opcodes */
15121   bfd_mips_num_opcodes = bfd_mips_num_builtin_opcodes;
15122   mips_opcodes = (struct mips_opcode *) mips_builtin_opcodes;
15123 }
15124
15125 long
15126 md_pcrel_from (fixS *fixP)
15127 {
15128   valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
15129   switch (fixP->fx_r_type)
15130     {
15131     case BFD_RELOC_MICROMIPS_7_PCREL_S1:
15132     case BFD_RELOC_MICROMIPS_10_PCREL_S1:
15133       /* Return the address of the delay slot.  */
15134       return addr + 2;
15135
15136     case BFD_RELOC_MICROMIPS_16_PCREL_S1:
15137     case BFD_RELOC_MICROMIPS_JMP:
15138     case BFD_RELOC_16_PCREL_S2:
15139     case BFD_RELOC_MIPS_JMP:
15140       /* Return the address of the delay slot.  */
15141       return addr + 4;
15142
15143     default:
15144       /* We have no relocation type for PC relative MIPS16 instructions.  */
15145       if (fixP->fx_addsy && S_GET_SEGMENT (fixP->fx_addsy) != now_seg)
15146         as_bad_where (fixP->fx_file, fixP->fx_line,
15147                       _("PC relative MIPS16 instruction references a different section"));
15148       return addr;
15149     }
15150 }
15151
15152 /* This is called before the symbol table is processed.  In order to
15153    work with gcc when using mips-tfile, we must keep all local labels.
15154    However, in other cases, we want to discard them.  If we were
15155    called with -g, but we didn't see any debugging information, it may
15156    mean that gcc is smuggling debugging information through to
15157    mips-tfile, in which case we must generate all local labels.  */
15158
15159 void
15160 mips_frob_file_before_adjust (void)
15161 {
15162 #ifndef NO_ECOFF_DEBUGGING
15163   if (ECOFF_DEBUGGING
15164       && mips_debug != 0
15165       && ! ecoff_debugging_seen)
15166     flag_keep_locals = 1;
15167 #endif
15168 }
15169
15170 /* Sort any unmatched HI16 and GOT16 relocs so that they immediately precede
15171    the corresponding LO16 reloc.  This is called before md_apply_fix and
15172    tc_gen_reloc.  Unmatched relocs can only be generated by use of explicit
15173    relocation operators.
15174
15175    For our purposes, a %lo() expression matches a %got() or %hi()
15176    expression if:
15177
15178       (a) it refers to the same symbol; and
15179       (b) the offset applied in the %lo() expression is no lower than
15180           the offset applied in the %got() or %hi().
15181
15182    (b) allows us to cope with code like:
15183
15184         lui     $4,%hi(foo)
15185         lh      $4,%lo(foo+2)($4)
15186
15187    ...which is legal on RELA targets, and has a well-defined behaviour
15188    if the user knows that adding 2 to "foo" will not induce a carry to
15189    the high 16 bits.
15190
15191    When several %lo()s match a particular %got() or %hi(), we use the
15192    following rules to distinguish them:
15193
15194      (1) %lo()s with smaller offsets are a better match than %lo()s with
15195          higher offsets.
15196
15197      (2) %lo()s with no matching %got() or %hi() are better than those
15198          that already have a matching %got() or %hi().
15199
15200      (3) later %lo()s are better than earlier %lo()s.
15201
15202    These rules are applied in order.
15203
15204    (1) means, among other things, that %lo()s with identical offsets are
15205    chosen if they exist.
15206
15207    (2) means that we won't associate several high-part relocations with
15208    the same low-part relocation unless there's no alternative.  Having
15209    several high parts for the same low part is a GNU extension; this rule
15210    allows careful users to avoid it.
15211
15212    (3) is purely cosmetic.  mips_hi_fixup_list is is in reverse order,
15213    with the last high-part relocation being at the front of the list.
15214    It therefore makes sense to choose the last matching low-part
15215    relocation, all other things being equal.  It's also easier
15216    to code that way.  */
15217
15218 void
15219 mips_frob_file (void)
15220 {
15221   struct mips_hi_fixup *l;
15222   bfd_reloc_code_real_type looking_for_rtype = BFD_RELOC_UNUSED;
15223
15224   for (l = mips_hi_fixup_list; l != NULL; l = l->next)
15225     {
15226       segment_info_type *seginfo;
15227       bfd_boolean matched_lo_p;
15228       fixS **hi_pos, **lo_pos, **pos;
15229
15230       gas_assert (reloc_needs_lo_p (l->fixp->fx_r_type));
15231
15232       /* If a GOT16 relocation turns out to be against a global symbol,
15233          there isn't supposed to be a matching LO.  */
15234       if (got16_reloc_p (l->fixp->fx_r_type)
15235           && !pic_need_relax (l->fixp->fx_addsy, l->seg))
15236         continue;
15237
15238       /* Check quickly whether the next fixup happens to be a matching %lo.  */
15239       if (fixup_has_matching_lo_p (l->fixp))
15240         continue;
15241
15242       seginfo = seg_info (l->seg);
15243
15244       /* Set HI_POS to the position of this relocation in the chain.
15245          Set LO_POS to the position of the chosen low-part relocation.
15246          MATCHED_LO_P is true on entry to the loop if *POS is a low-part
15247          relocation that matches an immediately-preceding high-part
15248          relocation.  */
15249       hi_pos = NULL;
15250       lo_pos = NULL;
15251       matched_lo_p = FALSE;
15252       looking_for_rtype = matching_lo_reloc (l->fixp->fx_r_type);
15253
15254       for (pos = &seginfo->fix_root; *pos != NULL; pos = &(*pos)->fx_next)
15255         {
15256           if (*pos == l->fixp)
15257             hi_pos = pos;
15258
15259           if ((*pos)->fx_r_type == looking_for_rtype
15260               && symbol_same_p ((*pos)->fx_addsy, l->fixp->fx_addsy)
15261               && (*pos)->fx_offset >= l->fixp->fx_offset
15262               && (lo_pos == NULL
15263                   || (*pos)->fx_offset < (*lo_pos)->fx_offset
15264                   || (!matched_lo_p
15265                       && (*pos)->fx_offset == (*lo_pos)->fx_offset)))
15266             lo_pos = pos;
15267
15268           matched_lo_p = (reloc_needs_lo_p ((*pos)->fx_r_type)
15269                           && fixup_has_matching_lo_p (*pos));
15270         }
15271
15272       /* If we found a match, remove the high-part relocation from its
15273          current position and insert it before the low-part relocation.
15274          Make the offsets match so that fixup_has_matching_lo_p()
15275          will return true.
15276
15277          We don't warn about unmatched high-part relocations since some
15278          versions of gcc have been known to emit dead "lui ...%hi(...)"
15279          instructions.  */
15280       if (lo_pos != NULL)
15281         {
15282           l->fixp->fx_offset = (*lo_pos)->fx_offset;
15283           if (l->fixp->fx_next != *lo_pos)
15284             {
15285               *hi_pos = l->fixp->fx_next;
15286               l->fixp->fx_next = *lo_pos;
15287               *lo_pos = l->fixp;
15288             }
15289         }
15290     }
15291 }
15292
15293 /* We may have combined relocations without symbols in the N32/N64 ABI.
15294    We have to prevent gas from dropping them.  */
15295
15296 int
15297 mips_force_relocation (fixS *fixp)
15298 {
15299   if (generic_force_reloc (fixp))
15300     return 1;
15301
15302   /* We want to keep BFD_RELOC_MICROMIPS_*_PCREL_S1 relocation,
15303      so that the linker relaxation can update targets.  */
15304   if (fixp->fx_r_type == BFD_RELOC_MICROMIPS_7_PCREL_S1
15305       || fixp->fx_r_type == BFD_RELOC_MICROMIPS_10_PCREL_S1
15306       || fixp->fx_r_type == BFD_RELOC_MICROMIPS_16_PCREL_S1)
15307     return 1;
15308
15309   if (HAVE_NEWABI
15310       && S_GET_SEGMENT (fixp->fx_addsy) == bfd_abs_section_ptr
15311       && (fixp->fx_r_type == BFD_RELOC_MIPS_SUB
15312           || hi16_reloc_p (fixp->fx_r_type)
15313           || lo16_reloc_p (fixp->fx_r_type)))
15314     return 1;
15315
15316   return 0;
15317 }
15318
15319 /* Apply a fixup to the object file.  */
15320
15321 void
15322 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
15323 {
15324   bfd_byte *buf;
15325   long insn;
15326   reloc_howto_type *howto;
15327
15328   /* We ignore generic BFD relocations we don't know about.  */
15329   howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
15330   if (! howto)
15331     return;
15332
15333   gas_assert (fixP->fx_size == 2
15334               || fixP->fx_size == 4
15335               || fixP->fx_r_type == BFD_RELOC_16
15336               || fixP->fx_r_type == BFD_RELOC_64
15337               || fixP->fx_r_type == BFD_RELOC_CTOR
15338               || fixP->fx_r_type == BFD_RELOC_MIPS_SUB
15339               || fixP->fx_r_type == BFD_RELOC_MICROMIPS_SUB
15340               || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
15341               || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
15342               || fixP->fx_r_type == BFD_RELOC_MIPS_TLS_DTPREL64);
15343
15344   buf = (bfd_byte *) (fixP->fx_frag->fr_literal + fixP->fx_where);
15345
15346   gas_assert (!fixP->fx_pcrel || fixP->fx_r_type == BFD_RELOC_16_PCREL_S2
15347               || fixP->fx_r_type == BFD_RELOC_MICROMIPS_7_PCREL_S1
15348               || fixP->fx_r_type == BFD_RELOC_MICROMIPS_10_PCREL_S1
15349               || fixP->fx_r_type == BFD_RELOC_MICROMIPS_16_PCREL_S1);
15350
15351   /* Don't treat parts of a composite relocation as done.  There are two
15352      reasons for this:
15353
15354      (1) The second and third parts will be against 0 (RSS_UNDEF) but
15355          should nevertheless be emitted if the first part is.
15356
15357      (2) In normal usage, composite relocations are never assembly-time
15358          constants.  The easiest way of dealing with the pathological
15359          exceptions is to generate a relocation against STN_UNDEF and
15360          leave everything up to the linker.  */
15361   if (fixP->fx_addsy == NULL && !fixP->fx_pcrel && fixP->fx_tcbit == 0)
15362     fixP->fx_done = 1;
15363
15364   switch (fixP->fx_r_type)
15365     {
15366     case BFD_RELOC_MIPS_TLS_GD:
15367     case BFD_RELOC_MIPS_TLS_LDM:
15368     case BFD_RELOC_MIPS_TLS_DTPREL32:
15369     case BFD_RELOC_MIPS_TLS_DTPREL64:
15370     case BFD_RELOC_MIPS_TLS_DTPREL_HI16:
15371     case BFD_RELOC_MIPS_TLS_DTPREL_LO16:
15372     case BFD_RELOC_MIPS_TLS_GOTTPREL:
15373     case BFD_RELOC_MIPS_TLS_TPREL_HI16:
15374     case BFD_RELOC_MIPS_TLS_TPREL_LO16:
15375     case BFD_RELOC_MICROMIPS_TLS_GD:
15376     case BFD_RELOC_MICROMIPS_TLS_LDM:
15377     case BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16:
15378     case BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16:
15379     case BFD_RELOC_MICROMIPS_TLS_GOTTPREL:
15380     case BFD_RELOC_MICROMIPS_TLS_TPREL_HI16:
15381     case BFD_RELOC_MICROMIPS_TLS_TPREL_LO16:
15382       S_SET_THREAD_LOCAL (fixP->fx_addsy);
15383       /* fall through */
15384
15385     case BFD_RELOC_MIPS_JMP:
15386     case BFD_RELOC_MIPS_SHIFT5:
15387     case BFD_RELOC_MIPS_SHIFT6:
15388     case BFD_RELOC_MIPS_GOT_DISP:
15389     case BFD_RELOC_MIPS_GOT_PAGE:
15390     case BFD_RELOC_MIPS_GOT_OFST:
15391     case BFD_RELOC_MIPS_SUB:
15392     case BFD_RELOC_MIPS_INSERT_A:
15393     case BFD_RELOC_MIPS_INSERT_B:
15394     case BFD_RELOC_MIPS_DELETE:
15395     case BFD_RELOC_MIPS_HIGHEST:
15396     case BFD_RELOC_MIPS_HIGHER:
15397     case BFD_RELOC_MIPS_SCN_DISP:
15398     case BFD_RELOC_MIPS_REL16:
15399     case BFD_RELOC_MIPS_RELGOT:
15400     case BFD_RELOC_MIPS_JALR:
15401     case BFD_RELOC_HI16:
15402     case BFD_RELOC_HI16_S:
15403     case BFD_RELOC_GPREL16:
15404     case BFD_RELOC_MIPS_LITERAL:
15405     case BFD_RELOC_MIPS_CALL16:
15406     case BFD_RELOC_MIPS_GOT16:
15407     case BFD_RELOC_GPREL32:
15408     case BFD_RELOC_MIPS_GOT_HI16:
15409     case BFD_RELOC_MIPS_GOT_LO16:
15410     case BFD_RELOC_MIPS_CALL_HI16:
15411     case BFD_RELOC_MIPS_CALL_LO16:
15412     case BFD_RELOC_MIPS16_GPREL:
15413     case BFD_RELOC_MIPS16_GOT16:
15414     case BFD_RELOC_MIPS16_CALL16:
15415     case BFD_RELOC_MIPS16_HI16:
15416     case BFD_RELOC_MIPS16_HI16_S:
15417     case BFD_RELOC_MIPS16_JMP:
15418     case BFD_RELOC_MICROMIPS_JMP:
15419     case BFD_RELOC_MICROMIPS_GOT_DISP:
15420     case BFD_RELOC_MICROMIPS_GOT_PAGE:
15421     case BFD_RELOC_MICROMIPS_GOT_OFST:
15422     case BFD_RELOC_MICROMIPS_SUB:
15423     case BFD_RELOC_MICROMIPS_HIGHEST:
15424     case BFD_RELOC_MICROMIPS_HIGHER:
15425     case BFD_RELOC_MICROMIPS_SCN_DISP:
15426     case BFD_RELOC_MICROMIPS_JALR:
15427     case BFD_RELOC_MICROMIPS_HI16:
15428     case BFD_RELOC_MICROMIPS_HI16_S:
15429     case BFD_RELOC_MICROMIPS_GPREL16:
15430     case BFD_RELOC_MICROMIPS_LITERAL:
15431     case BFD_RELOC_MICROMIPS_CALL16:
15432     case BFD_RELOC_MICROMIPS_GOT16:
15433     case BFD_RELOC_MICROMIPS_GOT_HI16:
15434     case BFD_RELOC_MICROMIPS_GOT_LO16:
15435     case BFD_RELOC_MICROMIPS_CALL_HI16:
15436     case BFD_RELOC_MICROMIPS_CALL_LO16:
15437       /* Nothing needed to do.  The value comes from the reloc entry.  */
15438       break;
15439
15440     case BFD_RELOC_64:
15441       /* This is handled like BFD_RELOC_32, but we output a sign
15442          extended value if we are only 32 bits.  */
15443       if (fixP->fx_done)
15444         {
15445           if (8 <= sizeof (valueT))
15446             md_number_to_chars ((char *) buf, *valP, 8);
15447           else
15448             {
15449               valueT hiv;
15450
15451               if ((*valP & 0x80000000) != 0)
15452                 hiv = 0xffffffff;
15453               else
15454                 hiv = 0;
15455               md_number_to_chars ((char *)(buf + (target_big_endian ? 4 : 0)),
15456                                   *valP, 4);
15457               md_number_to_chars ((char *)(buf + (target_big_endian ? 0 : 4)),
15458                                   hiv, 4);
15459             }
15460         }
15461       break;
15462
15463     case BFD_RELOC_RVA:
15464     case BFD_RELOC_32:
15465     case BFD_RELOC_16:
15466       /* If we are deleting this reloc entry, we must fill in the
15467          value now.  This can happen if we have a .word which is not
15468          resolved when it appears but is later defined.  */
15469       if (fixP->fx_done)
15470         md_number_to_chars ((char *) buf, *valP, fixP->fx_size);
15471       break;
15472
15473     case BFD_RELOC_LO16:
15474     case BFD_RELOC_MIPS16_LO16:
15475     case BFD_RELOC_MICROMIPS_LO16:
15476       /* FIXME: Now that embedded-PIC is gone, some of this code/comment
15477          may be safe to remove, but if so it's not obvious.  */
15478       /* When handling an embedded PIC switch statement, we can wind
15479          up deleting a LO16 reloc.  See the 'o' case in mips_ip.  */
15480       if (fixP->fx_done)
15481         {
15482           if (*valP + 0x8000 > 0xffff)
15483             as_bad_where (fixP->fx_file, fixP->fx_line,
15484                           _("relocation overflow"));
15485           /* 32-bit microMIPS instructions are divided into two halfwords.
15486              Relocations always refer to the second halfword, regardless
15487              of endianness.  */
15488           if (target_big_endian || fixP->fx_r_type == BFD_RELOC_MICROMIPS_LO16)
15489             buf += 2;
15490           md_number_to_chars ((char *) buf, *valP, 2);
15491         }
15492       break;
15493
15494     case BFD_RELOC_16_PCREL_S2:
15495       if ((*valP & 0x3) != 0)
15496         as_bad_where (fixP->fx_file, fixP->fx_line,
15497                       _("Branch to misaligned address (%lx)"), (long) *valP);
15498
15499       /* We need to save the bits in the instruction since fixup_segment()
15500          might be deleting the relocation entry (i.e., a branch within
15501          the current segment).  */
15502       if (! fixP->fx_done)
15503         break;
15504
15505       /* Update old instruction data.  */
15506       if (target_big_endian)
15507         insn = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
15508       else
15509         insn = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
15510
15511       if (*valP + 0x20000 <= 0x3ffff)
15512         {
15513           insn |= (*valP >> 2) & 0xffff;
15514           md_number_to_chars ((char *) buf, insn, 4);
15515         }
15516       else if (mips_pic == NO_PIC
15517                && fixP->fx_done
15518                && fixP->fx_frag->fr_address >= text_section->vma
15519                && (fixP->fx_frag->fr_address
15520                    < text_section->vma + bfd_get_section_size (text_section))
15521                && ((insn & 0xffff0000) == 0x10000000     /* beq $0,$0 */
15522                    || (insn & 0xffff0000) == 0x04010000  /* bgez $0 */
15523                    || (insn & 0xffff0000) == 0x04110000)) /* bgezal $0 */
15524         {
15525           /* The branch offset is too large.  If this is an
15526              unconditional branch, and we are not generating PIC code,
15527              we can convert it to an absolute jump instruction.  */
15528           if ((insn & 0xffff0000) == 0x04110000)         /* bgezal $0 */
15529             insn = 0x0c000000;  /* jal */
15530           else
15531             insn = 0x08000000;  /* j */
15532           fixP->fx_r_type = BFD_RELOC_MIPS_JMP;
15533           fixP->fx_done = 0;
15534           fixP->fx_addsy = section_symbol (text_section);
15535           *valP += md_pcrel_from (fixP);
15536           md_number_to_chars ((char *) buf, insn, 4);
15537         }
15538       else
15539         {
15540           /* If we got here, we have branch-relaxation disabled,
15541              and there's nothing we can do to fix this instruction
15542              without turning it into a longer sequence.  */
15543           as_bad_where (fixP->fx_file, fixP->fx_line,
15544                         _("Branch out of range"));
15545         }
15546       break;
15547
15548     case BFD_RELOC_MICROMIPS_7_PCREL_S1:
15549     case BFD_RELOC_MICROMIPS_10_PCREL_S1:
15550     case BFD_RELOC_MICROMIPS_16_PCREL_S1:
15551       /* We adjust the offset back to even.  */
15552       if ((*valP & 0x1) != 0)
15553         --(*valP);
15554
15555       if (! fixP->fx_done)
15556         break;
15557
15558       /* Should never visit here, because we keep the relocation.  */
15559       abort ();
15560       break;
15561
15562     case BFD_RELOC_VTABLE_INHERIT:
15563       fixP->fx_done = 0;
15564       if (fixP->fx_addsy
15565           && !S_IS_DEFINED (fixP->fx_addsy)
15566           && !S_IS_WEAK (fixP->fx_addsy))
15567         S_SET_WEAK (fixP->fx_addsy);
15568       break;
15569
15570     case BFD_RELOC_VTABLE_ENTRY:
15571       fixP->fx_done = 0;
15572       break;
15573
15574     default:
15575       internalError ();
15576     }
15577
15578   /* Remember value for tc_gen_reloc.  */
15579   fixP->fx_addnumber = *valP;
15580 }
15581
15582 static symbolS *
15583 get_symbol (void)
15584 {
15585   int c;
15586   char *name;
15587   symbolS *p;
15588
15589   name = input_line_pointer;
15590   c = get_symbol_end ();
15591   p = (symbolS *) symbol_find_or_make (name);
15592   *input_line_pointer = c;
15593   return p;
15594 }
15595
15596 /* Align the current frag to a given power of two.  If a particular
15597    fill byte should be used, FILL points to an integer that contains
15598    that byte, otherwise FILL is null.
15599
15600    The MIPS assembler also automatically adjusts any preceding
15601    label.  */
15602
15603 static void
15604 mips_align (int to, int *fill, symbolS *label)
15605 {
15606   mips_emit_delays ();
15607   mips_record_compressed_mode ();
15608   if (fill == NULL && subseg_text_p (now_seg))
15609     frag_align_code (to, 0);
15610   else
15611     frag_align (to, fill ? *fill : 0, 0);
15612   record_alignment (now_seg, to);
15613   if (label != NULL)
15614     {
15615       gas_assert (S_GET_SEGMENT (label) == now_seg);
15616       symbol_set_frag (label, frag_now);
15617       S_SET_VALUE (label, (valueT) frag_now_fix ());
15618     }
15619 }
15620
15621 /* Align to a given power of two.  .align 0 turns off the automatic
15622    alignment used by the data creating pseudo-ops.  */
15623
15624 static void
15625 s_align (int x ATTRIBUTE_UNUSED)
15626 {
15627   int temp, fill_value, *fill_ptr;
15628   long max_alignment = 28;
15629
15630   /* o Note that the assembler pulls down any immediately preceding label
15631        to the aligned address.
15632      o It's not documented but auto alignment is reinstated by
15633        a .align pseudo instruction.
15634      o Note also that after auto alignment is turned off the mips assembler
15635        issues an error on attempt to assemble an improperly aligned data item.
15636        We don't.  */
15637
15638   temp = get_absolute_expression ();
15639   if (temp > max_alignment)
15640     as_bad (_("Alignment too large: %d. assumed."), temp = max_alignment);
15641   else if (temp < 0)
15642     {
15643       as_warn (_("Alignment negative: 0 assumed."));
15644       temp = 0;
15645     }
15646   if (*input_line_pointer == ',')
15647     {
15648       ++input_line_pointer;
15649       fill_value = get_absolute_expression ();
15650       fill_ptr = &fill_value;
15651     }
15652   else
15653     fill_ptr = 0;
15654   if (temp)
15655     {
15656       segment_info_type *si = seg_info (now_seg);
15657       struct insn_label_list *l = si->label_list;
15658       /* Auto alignment should be switched on by next section change.  */
15659       auto_align = 1;
15660       mips_align (temp, fill_ptr, l != NULL ? l->label : NULL);
15661     }
15662   else
15663     {
15664       auto_align = 0;
15665     }
15666
15667   demand_empty_rest_of_line ();
15668 }
15669
15670 static void
15671 s_change_sec (int sec)
15672 {
15673   segT seg;
15674
15675 #ifdef OBJ_ELF
15676   /* The ELF backend needs to know that we are changing sections, so
15677      that .previous works correctly.  We could do something like check
15678      for an obj_section_change_hook macro, but that might be confusing
15679      as it would not be appropriate to use it in the section changing
15680      functions in read.c, since obj-elf.c intercepts those.  FIXME:
15681      This should be cleaner, somehow.  */
15682   if (IS_ELF)
15683     obj_elf_section_change_hook ();
15684 #endif
15685
15686   mips_emit_delays ();
15687
15688   switch (sec)
15689     {
15690     case 't':
15691       s_text (0);
15692       break;
15693     case 'd':
15694       s_data (0);
15695       break;
15696     case 'b':
15697       subseg_set (bss_section, (subsegT) get_absolute_expression ());
15698       demand_empty_rest_of_line ();
15699       break;
15700
15701     case 'r':
15702       seg = subseg_new (RDATA_SECTION_NAME,
15703                         (subsegT) get_absolute_expression ());
15704       if (IS_ELF)
15705         {
15706           bfd_set_section_flags (stdoutput, seg, (SEC_ALLOC | SEC_LOAD
15707                                                   | SEC_READONLY | SEC_RELOC
15708                                                   | SEC_DATA));
15709           if (strncmp (TARGET_OS, "elf", 3) != 0)
15710             record_alignment (seg, 4);
15711         }
15712       demand_empty_rest_of_line ();
15713       break;
15714
15715     case 's':
15716       seg = subseg_new (".sdata", (subsegT) get_absolute_expression ());
15717       if (IS_ELF)
15718         {
15719           bfd_set_section_flags (stdoutput, seg,
15720                                  SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA);
15721           if (strncmp (TARGET_OS, "elf", 3) != 0)
15722             record_alignment (seg, 4);
15723         }
15724       demand_empty_rest_of_line ();
15725       break;
15726
15727     case 'B':
15728       seg = subseg_new (".sbss", (subsegT) get_absolute_expression ());
15729       if (IS_ELF)
15730         {
15731           bfd_set_section_flags (stdoutput, seg, SEC_ALLOC);
15732           if (strncmp (TARGET_OS, "elf", 3) != 0)
15733             record_alignment (seg, 4);
15734         }
15735       demand_empty_rest_of_line ();
15736       break;
15737     }
15738
15739   auto_align = 1;
15740 }
15741
15742 void
15743 s_change_section (int ignore ATTRIBUTE_UNUSED)
15744 {
15745 #ifdef OBJ_ELF
15746   char *section_name;
15747   char c;
15748   char next_c = 0;
15749   int section_type;
15750   int section_flag;
15751   int section_entry_size;
15752   int section_alignment;
15753
15754   if (!IS_ELF)
15755     return;
15756
15757   section_name = input_line_pointer;
15758   c = get_symbol_end ();
15759   if (c)
15760     next_c = *(input_line_pointer + 1);
15761
15762   /* Do we have .section Name<,"flags">?  */
15763   if (c != ',' || (c == ',' && next_c == '"'))
15764     {
15765       /* just after name is now '\0'.  */
15766       *input_line_pointer = c;
15767       input_line_pointer = section_name;
15768       obj_elf_section (ignore);
15769       return;
15770     }
15771   input_line_pointer++;
15772
15773   /* Do we have .section Name<,type><,flag><,entry_size><,alignment>  */
15774   if (c == ',')
15775     section_type = get_absolute_expression ();
15776   else
15777     section_type = 0;
15778   if (*input_line_pointer++ == ',')
15779     section_flag = get_absolute_expression ();
15780   else
15781     section_flag = 0;
15782   if (*input_line_pointer++ == ',')
15783     section_entry_size = get_absolute_expression ();
15784   else
15785     section_entry_size = 0;
15786   if (*input_line_pointer++ == ',')
15787     section_alignment = get_absolute_expression ();
15788   else
15789     section_alignment = 0;
15790   /* FIXME: really ignore?  */
15791   (void) section_alignment;
15792
15793   section_name = xstrdup (section_name);
15794
15795   /* When using the generic form of .section (as implemented by obj-elf.c),
15796      there's no way to set the section type to SHT_MIPS_DWARF.  Users have
15797      traditionally had to fall back on the more common @progbits instead.
15798
15799      There's nothing really harmful in this, since bfd will correct
15800      SHT_PROGBITS to SHT_MIPS_DWARF before writing out the file.  But it
15801      means that, for backwards compatibility, the special_section entries
15802      for dwarf sections must use SHT_PROGBITS rather than SHT_MIPS_DWARF.
15803
15804      Even so, we shouldn't force users of the MIPS .section syntax to
15805      incorrectly label the sections as SHT_PROGBITS.  The best compromise
15806      seems to be to map SHT_MIPS_DWARF to SHT_PROGBITS before calling the
15807      generic type-checking code.  */
15808   if (section_type == SHT_MIPS_DWARF)
15809     section_type = SHT_PROGBITS;
15810
15811   obj_elf_change_section (section_name, section_type, section_flag,
15812                           section_entry_size, 0, 0, 0);
15813
15814   if (now_seg->name != section_name)
15815     free (section_name);
15816 #endif /* OBJ_ELF */
15817 }
15818
15819 void
15820 mips_enable_auto_align (void)
15821 {
15822   auto_align = 1;
15823 }
15824
15825 static void
15826 s_cons (int log_size)
15827 {
15828   segment_info_type *si = seg_info (now_seg);
15829   struct insn_label_list *l = si->label_list;
15830   symbolS *label;
15831
15832   label = l != NULL ? l->label : NULL;
15833   mips_emit_delays ();
15834   if (log_size > 0 && auto_align)
15835     mips_align (log_size, 0, label);
15836   cons (1 << log_size);
15837   mips_clear_insn_labels ();
15838 }
15839
15840 static void
15841 s_float_cons (int type)
15842 {
15843   segment_info_type *si = seg_info (now_seg);
15844   struct insn_label_list *l = si->label_list;
15845   symbolS *label;
15846
15847   label = l != NULL ? l->label : NULL;
15848
15849   mips_emit_delays ();
15850
15851   if (auto_align)
15852     {
15853       if (type == 'd')
15854         mips_align (3, 0, label);
15855       else
15856         mips_align (2, 0, label);
15857     }
15858
15859   float_cons (type);
15860   mips_clear_insn_labels ();
15861 }
15862
15863 /* Handle .globl.  We need to override it because on Irix 5 you are
15864    permitted to say
15865        .globl foo .text
15866    where foo is an undefined symbol, to mean that foo should be
15867    considered to be the address of a function.  */
15868
15869 static void
15870 s_mips_globl (int x ATTRIBUTE_UNUSED)
15871 {
15872   char *name;
15873   int c;
15874   symbolS *symbolP;
15875   flagword flag;
15876
15877   do
15878     {
15879       name = input_line_pointer;
15880       c = get_symbol_end ();
15881       symbolP = symbol_find_or_make (name);
15882       S_SET_EXTERNAL (symbolP);
15883
15884       *input_line_pointer = c;
15885       SKIP_WHITESPACE ();
15886
15887       /* On Irix 5, every global symbol that is not explicitly labelled as
15888          being a function is apparently labelled as being an object.  */
15889       flag = BSF_OBJECT;
15890
15891       if (!is_end_of_line[(unsigned char) *input_line_pointer]
15892           && (*input_line_pointer != ','))
15893         {
15894           char *secname;
15895           asection *sec;
15896
15897           secname = input_line_pointer;
15898           c = get_symbol_end ();
15899           sec = bfd_get_section_by_name (stdoutput, secname);
15900           if (sec == NULL)
15901             as_bad (_("%s: no such section"), secname);
15902           *input_line_pointer = c;
15903
15904           if (sec != NULL && (sec->flags & SEC_CODE) != 0)
15905             flag = BSF_FUNCTION;
15906         }
15907
15908       symbol_get_bfdsym (symbolP)->flags |= flag;
15909
15910       c = *input_line_pointer;
15911       if (c == ',')
15912         {
15913           input_line_pointer++;
15914           SKIP_WHITESPACE ();
15915           if (is_end_of_line[(unsigned char) *input_line_pointer])
15916             c = '\n';
15917         }
15918     }
15919   while (c == ',');
15920
15921   demand_empty_rest_of_line ();
15922 }
15923
15924 static void
15925 s_option (int x ATTRIBUTE_UNUSED)
15926 {
15927   char *opt;
15928   char c;
15929
15930   opt = input_line_pointer;
15931   c = get_symbol_end ();
15932
15933   if (*opt == 'O')
15934     {
15935       /* FIXME: What does this mean?  */
15936     }
15937   else if (strncmp (opt, "pic", 3) == 0)
15938     {
15939       int i;
15940
15941       i = atoi (opt + 3);
15942       if (i == 0)
15943         mips_pic = NO_PIC;
15944       else if (i == 2)
15945         {
15946           mips_pic = SVR4_PIC;
15947           mips_abicalls = TRUE;
15948         }
15949       else
15950         as_bad (_(".option pic%d not supported"), i);
15951
15952       if (mips_pic == SVR4_PIC)
15953         {
15954           if (g_switch_seen && g_switch_value != 0)
15955             as_warn (_("-G may not be used with SVR4 PIC code"));
15956           g_switch_value = 0;
15957           bfd_set_gp_size (stdoutput, 0);
15958         }
15959     }
15960   else
15961     as_warn (_("Unrecognized option \"%s\""), opt);
15962
15963   *input_line_pointer = c;
15964   demand_empty_rest_of_line ();
15965 }
15966
15967 /* This structure is used to hold a stack of .set values.  */
15968
15969 struct mips_option_stack
15970 {
15971   struct mips_option_stack *next;
15972   struct mips_set_options options;
15973 };
15974
15975 static struct mips_option_stack *mips_opts_stack;
15976
15977 /* Handle the .set pseudo-op.  */
15978
15979 static void
15980 s_mipsset (int x ATTRIBUTE_UNUSED)
15981 {
15982   char *name = input_line_pointer, ch;
15983
15984   while (!is_end_of_line[(unsigned char) *input_line_pointer])
15985     ++input_line_pointer;
15986   ch = *input_line_pointer;
15987   *input_line_pointer = '\0';
15988
15989   if (strcmp (name, "reorder") == 0)
15990     {
15991       if (mips_opts.noreorder)
15992         end_noreorder ();
15993     }
15994   else if (strcmp (name, "noreorder") == 0)
15995     {
15996       if (!mips_opts.noreorder)
15997         start_noreorder ();
15998     }
15999   else if (strncmp (name, "at=", 3) == 0)
16000     {
16001       char *s = name + 3;
16002
16003       if (!reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &mips_opts.at))
16004         as_bad (_("Unrecognized register name `%s'"), s);
16005     }
16006   else if (strcmp (name, "at") == 0)
16007     {
16008       mips_opts.at = ATREG;
16009     }
16010   else if (strcmp (name, "noat") == 0)
16011     {
16012       mips_opts.at = ZERO;
16013     }
16014   else if (strcmp (name, "macro") == 0)
16015     {
16016       mips_opts.warn_about_macros = 0;
16017     }
16018   else if (strcmp (name, "nomacro") == 0)
16019     {
16020       if (mips_opts.noreorder == 0)
16021         as_bad (_("`noreorder' must be set before `nomacro'"));
16022       mips_opts.warn_about_macros = 1;
16023     }
16024   else if (strcmp (name, "move") == 0 || strcmp (name, "novolatile") == 0)
16025     {
16026       mips_opts.nomove = 0;
16027     }
16028   else if (strcmp (name, "nomove") == 0 || strcmp (name, "volatile") == 0)
16029     {
16030       mips_opts.nomove = 1;
16031     }
16032   else if (strcmp (name, "bopt") == 0)
16033     {
16034       mips_opts.nobopt = 0;
16035     }
16036   else if (strcmp (name, "nobopt") == 0)
16037     {
16038       mips_opts.nobopt = 1;
16039     }
16040   else if (strcmp (name, "gp=default") == 0)
16041     mips_opts.gp32 = file_mips_gp32;
16042   else if (strcmp (name, "gp=32") == 0)
16043     mips_opts.gp32 = 1;
16044   else if (strcmp (name, "gp=64") == 0)
16045     {
16046       if (!ISA_HAS_64BIT_REGS (mips_opts.isa))
16047         as_warn (_("%s isa does not support 64-bit registers"),
16048                  mips_cpu_info_from_isa (mips_opts.isa)->name);
16049       mips_opts.gp32 = 0;
16050     }
16051   else if (strcmp (name, "fp=default") == 0)
16052     mips_opts.fp32 = file_mips_fp32;
16053   else if (strcmp (name, "fp=32") == 0)
16054     mips_opts.fp32 = 1;
16055   else if (strcmp (name, "fp=64") == 0)
16056     {
16057       if (!ISA_HAS_64BIT_FPRS (mips_opts.isa))
16058         as_warn (_("%s isa does not support 64-bit floating point registers"),
16059                  mips_cpu_info_from_isa (mips_opts.isa)->name);
16060       mips_opts.fp32 = 0;
16061     }
16062   else if (strcmp (name, "softfloat") == 0)
16063     mips_opts.soft_float = 1;
16064   else if (strcmp (name, "hardfloat") == 0)
16065     mips_opts.soft_float = 0;
16066   else if (strcmp (name, "singlefloat") == 0)
16067     mips_opts.single_float = 1;
16068   else if (strcmp (name, "doublefloat") == 0)
16069     mips_opts.single_float = 0;
16070   else if (strcmp (name, "mips16") == 0
16071            || strcmp (name, "MIPS-16") == 0)
16072     {
16073       if (mips_opts.micromips == 1)
16074         as_fatal (_("`mips16' cannot be used with `micromips'"));
16075       mips_opts.mips16 = 1;
16076     }
16077   else if (strcmp (name, "nomips16") == 0
16078            || strcmp (name, "noMIPS-16") == 0)
16079     mips_opts.mips16 = 0;
16080   else if (strcmp (name, "micromips") == 0)
16081     {
16082       if (mips_opts.mips16 == 1)
16083         as_fatal (_("`micromips' cannot be used with `mips16'"));
16084       mips_opts.micromips = 1;
16085     }
16086   else if (strcmp (name, "nomicromips") == 0)
16087     mips_opts.micromips = 0;
16088   else if (strcmp (name, "smartmips") == 0)
16089     {
16090       if (!ISA_SUPPORTS_SMARTMIPS)
16091         as_warn (_("%s ISA does not support SmartMIPS ASE"), 
16092                  mips_cpu_info_from_isa (mips_opts.isa)->name);
16093       mips_opts.ase_smartmips = 1;
16094     }
16095   else if (strcmp (name, "nosmartmips") == 0)
16096     mips_opts.ase_smartmips = 0;
16097   else if (strcmp (name, "mips3d") == 0)
16098     mips_opts.ase_mips3d = 1;
16099   else if (strcmp (name, "nomips3d") == 0)
16100     mips_opts.ase_mips3d = 0;
16101   else if (strcmp (name, "mdmx") == 0)
16102     mips_opts.ase_mdmx = 1;
16103   else if (strcmp (name, "nomdmx") == 0)
16104     mips_opts.ase_mdmx = 0;
16105   else if (strcmp (name, "dsp") == 0)
16106     {
16107       if (!ISA_SUPPORTS_DSP_ASE)
16108         as_warn (_("%s ISA does not support DSP ASE"), 
16109                  mips_cpu_info_from_isa (mips_opts.isa)->name);
16110       mips_opts.ase_dsp = 1;
16111       mips_opts.ase_dspr2 = 0;
16112     }
16113   else if (strcmp (name, "nodsp") == 0)
16114     {
16115       mips_opts.ase_dsp = 0;
16116       mips_opts.ase_dspr2 = 0;
16117     }
16118   else if (strcmp (name, "dspr2") == 0)
16119     {
16120       if (!ISA_SUPPORTS_DSPR2_ASE)
16121         as_warn (_("%s ISA does not support DSP R2 ASE"),
16122                  mips_cpu_info_from_isa (mips_opts.isa)->name);
16123       mips_opts.ase_dspr2 = 1;
16124       mips_opts.ase_dsp = 1;
16125     }
16126   else if (strcmp (name, "nodspr2") == 0)
16127     {
16128       mips_opts.ase_dspr2 = 0;
16129       mips_opts.ase_dsp = 0;
16130     }
16131   else if (strcmp (name, "mt") == 0)
16132     {
16133       if (!ISA_SUPPORTS_MT_ASE)
16134         as_warn (_("%s ISA does not support MT ASE"), 
16135                  mips_cpu_info_from_isa (mips_opts.isa)->name);
16136       mips_opts.ase_mt = 1;
16137     }
16138   else if (strcmp (name, "nomt") == 0)
16139     mips_opts.ase_mt = 0;
16140   else if (strcmp (name, "mcu") == 0)
16141     mips_opts.ase_mcu = 1;
16142   else if (strcmp (name, "nomcu") == 0)
16143     mips_opts.ase_mcu = 0;
16144   else if (strncmp (name, "mips", 4) == 0 || strncmp (name, "arch=", 5) == 0)
16145     {
16146       int reset = 0;
16147
16148       /* Permit the user to change the ISA and architecture on the fly.
16149          Needless to say, misuse can cause serious problems.  */
16150       if (strcmp (name, "mips0") == 0 || strcmp (name, "arch=default") == 0)
16151         {
16152           reset = 1;
16153           mips_opts.isa = file_mips_isa;
16154           mips_opts.arch = file_mips_arch;
16155         }
16156       else if (strncmp (name, "arch=", 5) == 0)
16157         {
16158           const struct mips_cpu_info *p;
16159
16160           p = mips_parse_cpu("internal use", name + 5);
16161           if (!p)
16162             as_bad (_("unknown architecture %s"), name + 5);
16163           else
16164             {
16165               mips_opts.arch = p->cpu;
16166               mips_opts.isa = p->isa;
16167             }
16168         }
16169       else if (strncmp (name, "mips", 4) == 0)
16170         {
16171           const struct mips_cpu_info *p;
16172
16173           p = mips_parse_cpu("internal use", name);
16174           if (!p)
16175             as_bad (_("unknown ISA level %s"), name + 4);
16176           else
16177             {
16178               mips_opts.arch = p->cpu;
16179               mips_opts.isa = p->isa;
16180             }
16181         }
16182       else
16183         as_bad (_("unknown ISA or architecture %s"), name);
16184
16185       switch (mips_opts.isa)
16186         {
16187         case  0:
16188           break;
16189         case ISA_MIPS1:
16190         case ISA_MIPS2:
16191         case ISA_MIPS32:
16192         case ISA_MIPS32R2:
16193           mips_opts.gp32 = 1;
16194           mips_opts.fp32 = 1;
16195           break;
16196         case ISA_MIPS3:
16197         case ISA_MIPS4:
16198         case ISA_MIPS5:
16199         case ISA_MIPS64:
16200         case ISA_MIPS64R2:
16201           mips_opts.gp32 = 0;
16202           mips_opts.fp32 = 0;
16203           break;
16204         default:
16205           as_bad (_("unknown ISA level %s"), name + 4);
16206           break;
16207         }
16208       if (reset)
16209         {
16210           mips_opts.gp32 = file_mips_gp32;
16211           mips_opts.fp32 = file_mips_fp32;
16212         }
16213     }
16214   else if (strcmp (name, "autoextend") == 0)
16215     mips_opts.noautoextend = 0;
16216   else if (strcmp (name, "noautoextend") == 0)
16217     mips_opts.noautoextend = 1;
16218   else if (strcmp (name, "push") == 0)
16219     {
16220       struct mips_option_stack *s;
16221
16222       s = (struct mips_option_stack *) xmalloc (sizeof *s);
16223       s->next = mips_opts_stack;
16224       s->options = mips_opts;
16225       mips_opts_stack = s;
16226     }
16227   else if (strcmp (name, "pop") == 0)
16228     {
16229       struct mips_option_stack *s;
16230
16231       s = mips_opts_stack;
16232       if (s == NULL)
16233         as_bad (_(".set pop with no .set push"));
16234       else
16235         {
16236           /* If we're changing the reorder mode we need to handle
16237              delay slots correctly.  */
16238           if (s->options.noreorder && ! mips_opts.noreorder)
16239             start_noreorder ();
16240           else if (! s->options.noreorder && mips_opts.noreorder)
16241             end_noreorder ();
16242
16243           mips_opts = s->options;
16244           mips_opts_stack = s->next;
16245           free (s);
16246         }
16247     }
16248   else if (strcmp (name, "sym32") == 0)
16249     mips_opts.sym32 = TRUE;
16250   else if (strcmp (name, "nosym32") == 0)
16251     mips_opts.sym32 = FALSE;
16252   else if (strchr (name, ','))
16253     {
16254       /* Generic ".set" directive; use the generic handler.  */
16255       *input_line_pointer = ch;
16256       input_line_pointer = name;
16257       s_set (0);
16258       return;
16259     }
16260   else
16261     {
16262       as_warn (_("Tried to set unrecognized symbol: %s\n"), name);
16263     }
16264   *input_line_pointer = ch;
16265   demand_empty_rest_of_line ();
16266 }
16267
16268 /* Handle the .abicalls pseudo-op.  I believe this is equivalent to
16269    .option pic2.  It means to generate SVR4 PIC calls.  */
16270
16271 static void
16272 s_abicalls (int ignore ATTRIBUTE_UNUSED)
16273 {
16274   mips_pic = SVR4_PIC;
16275   mips_abicalls = TRUE;
16276
16277   if (g_switch_seen && g_switch_value != 0)
16278     as_warn (_("-G may not be used with SVR4 PIC code"));
16279   g_switch_value = 0;
16280
16281   bfd_set_gp_size (stdoutput, 0);
16282   demand_empty_rest_of_line ();
16283 }
16284
16285 /* Handle the .cpload pseudo-op.  This is used when generating SVR4
16286    PIC code.  It sets the $gp register for the function based on the
16287    function address, which is in the register named in the argument.
16288    This uses a relocation against _gp_disp, which is handled specially
16289    by the linker.  The result is:
16290         lui     $gp,%hi(_gp_disp)
16291         addiu   $gp,$gp,%lo(_gp_disp)
16292         addu    $gp,$gp,.cpload argument
16293    The .cpload argument is normally $25 == $t9.
16294
16295    The -mno-shared option changes this to:
16296         lui     $gp,%hi(__gnu_local_gp)
16297         addiu   $gp,$gp,%lo(__gnu_local_gp)
16298    and the argument is ignored.  This saves an instruction, but the
16299    resulting code is not position independent; it uses an absolute
16300    address for __gnu_local_gp.  Thus code assembled with -mno-shared
16301    can go into an ordinary executable, but not into a shared library.  */
16302
16303 static void
16304 s_cpload (int ignore ATTRIBUTE_UNUSED)
16305 {
16306   expressionS ex;
16307   int reg;
16308   int in_shared;
16309
16310   /* If we are not generating SVR4 PIC code, or if this is NewABI code,
16311      .cpload is ignored.  */
16312   if (mips_pic != SVR4_PIC || HAVE_NEWABI)
16313     {
16314       s_ignore (0);
16315       return;
16316     }
16317
16318   /* .cpload should be in a .set noreorder section.  */
16319   if (mips_opts.noreorder == 0)
16320     as_warn (_(".cpload not in noreorder section"));
16321
16322   reg = tc_get_register (0);
16323
16324   /* If we need to produce a 64-bit address, we are better off using
16325      the default instruction sequence.  */
16326   in_shared = mips_in_shared || HAVE_64BIT_SYMBOLS;
16327
16328   ex.X_op = O_symbol;
16329   ex.X_add_symbol = symbol_find_or_make (in_shared ? "_gp_disp" :
16330                                          "__gnu_local_gp");
16331   ex.X_op_symbol = NULL;
16332   ex.X_add_number = 0;
16333
16334   /* In ELF, this symbol is implicitly an STT_OBJECT symbol.  */
16335   symbol_get_bfdsym (ex.X_add_symbol)->flags |= BSF_OBJECT;
16336
16337   macro_start ();
16338   macro_build_lui (&ex, mips_gp_register);
16339   macro_build (&ex, "addiu", "t,r,j", mips_gp_register,
16340                mips_gp_register, BFD_RELOC_LO16);
16341   if (in_shared)
16342     macro_build (NULL, "addu", "d,v,t", mips_gp_register,
16343                  mips_gp_register, reg);
16344   macro_end ();
16345
16346   demand_empty_rest_of_line ();
16347 }
16348
16349 /* Handle the .cpsetup pseudo-op defined for NewABI PIC code.  The syntax is:
16350      .cpsetup $reg1, offset|$reg2, label
16351
16352    If offset is given, this results in:
16353      sd         $gp, offset($sp)
16354      lui        $gp, %hi(%neg(%gp_rel(label)))
16355      addiu      $gp, $gp, %lo(%neg(%gp_rel(label)))
16356      daddu      $gp, $gp, $reg1
16357
16358    If $reg2 is given, this results in:
16359      daddu      $reg2, $gp, $0
16360      lui        $gp, %hi(%neg(%gp_rel(label)))
16361      addiu      $gp, $gp, %lo(%neg(%gp_rel(label)))
16362      daddu      $gp, $gp, $reg1
16363    $reg1 is normally $25 == $t9.
16364
16365    The -mno-shared option replaces the last three instructions with
16366         lui     $gp,%hi(_gp)
16367         addiu   $gp,$gp,%lo(_gp)  */
16368
16369 static void
16370 s_cpsetup (int ignore ATTRIBUTE_UNUSED)
16371 {
16372   expressionS ex_off;
16373   expressionS ex_sym;
16374   int reg1;
16375
16376   /* If we are not generating SVR4 PIC code, .cpsetup is ignored.
16377      We also need NewABI support.  */
16378   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
16379     {
16380       s_ignore (0);
16381       return;
16382     }
16383
16384   reg1 = tc_get_register (0);
16385   SKIP_WHITESPACE ();
16386   if (*input_line_pointer != ',')
16387     {
16388       as_bad (_("missing argument separator ',' for .cpsetup"));
16389       return;
16390     }
16391   else
16392     ++input_line_pointer;
16393   SKIP_WHITESPACE ();
16394   if (*input_line_pointer == '$')
16395     {
16396       mips_cpreturn_register = tc_get_register (0);
16397       mips_cpreturn_offset = -1;
16398     }
16399   else
16400     {
16401       mips_cpreturn_offset = get_absolute_expression ();
16402       mips_cpreturn_register = -1;
16403     }
16404   SKIP_WHITESPACE ();
16405   if (*input_line_pointer != ',')
16406     {
16407       as_bad (_("missing argument separator ',' for .cpsetup"));
16408       return;
16409     }
16410   else
16411     ++input_line_pointer;
16412   SKIP_WHITESPACE ();
16413   expression (&ex_sym);
16414
16415   macro_start ();
16416   if (mips_cpreturn_register == -1)
16417     {
16418       ex_off.X_op = O_constant;
16419       ex_off.X_add_symbol = NULL;
16420       ex_off.X_op_symbol = NULL;
16421       ex_off.X_add_number = mips_cpreturn_offset;
16422
16423       macro_build (&ex_off, "sd", "t,o(b)", mips_gp_register,
16424                    BFD_RELOC_LO16, SP);
16425     }
16426   else
16427     macro_build (NULL, "daddu", "d,v,t", mips_cpreturn_register,
16428                  mips_gp_register, 0);
16429
16430   if (mips_in_shared || HAVE_64BIT_SYMBOLS)
16431     {
16432       macro_build (&ex_sym, "lui", LUI_FMT, mips_gp_register,
16433                    -1, BFD_RELOC_GPREL16, BFD_RELOC_MIPS_SUB,
16434                    BFD_RELOC_HI16_S);
16435
16436       macro_build (&ex_sym, "addiu", "t,r,j", mips_gp_register,
16437                    mips_gp_register, -1, BFD_RELOC_GPREL16,
16438                    BFD_RELOC_MIPS_SUB, BFD_RELOC_LO16);
16439
16440       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", mips_gp_register,
16441                    mips_gp_register, reg1);
16442     }
16443   else
16444     {
16445       expressionS ex;
16446
16447       ex.X_op = O_symbol;
16448       ex.X_add_symbol = symbol_find_or_make ("__gnu_local_gp");
16449       ex.X_op_symbol = NULL;
16450       ex.X_add_number = 0;
16451
16452       /* In ELF, this symbol is implicitly an STT_OBJECT symbol.  */
16453       symbol_get_bfdsym (ex.X_add_symbol)->flags |= BSF_OBJECT;
16454
16455       macro_build_lui (&ex, mips_gp_register);
16456       macro_build (&ex, "addiu", "t,r,j", mips_gp_register,
16457                    mips_gp_register, BFD_RELOC_LO16);
16458     }
16459
16460   macro_end ();
16461
16462   demand_empty_rest_of_line ();
16463 }
16464
16465 static void
16466 s_cplocal (int ignore ATTRIBUTE_UNUSED)
16467 {
16468   /* If we are not generating SVR4 PIC code, or if this is not NewABI code,
16469      .cplocal is ignored.  */
16470   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
16471     {
16472       s_ignore (0);
16473       return;
16474     }
16475
16476   mips_gp_register = tc_get_register (0);
16477   demand_empty_rest_of_line ();
16478 }
16479
16480 /* Handle the .cprestore pseudo-op.  This stores $gp into a given
16481    offset from $sp.  The offset is remembered, and after making a PIC
16482    call $gp is restored from that location.  */
16483
16484 static void
16485 s_cprestore (int ignore ATTRIBUTE_UNUSED)
16486 {
16487   expressionS ex;
16488
16489   /* If we are not generating SVR4 PIC code, or if this is NewABI code,
16490      .cprestore is ignored.  */
16491   if (mips_pic != SVR4_PIC || HAVE_NEWABI)
16492     {
16493       s_ignore (0);
16494       return;
16495     }
16496
16497   mips_cprestore_offset = get_absolute_expression ();
16498   mips_cprestore_valid = 1;
16499
16500   ex.X_op = O_constant;
16501   ex.X_add_symbol = NULL;
16502   ex.X_op_symbol = NULL;
16503   ex.X_add_number = mips_cprestore_offset;
16504
16505   macro_start ();
16506   macro_build_ldst_constoffset (&ex, ADDRESS_STORE_INSN, mips_gp_register,
16507                                 SP, HAVE_64BIT_ADDRESSES);
16508   macro_end ();
16509
16510   demand_empty_rest_of_line ();
16511 }
16512
16513 /* Handle the .cpreturn pseudo-op defined for NewABI PIC code. If an offset
16514    was given in the preceding .cpsetup, it results in:
16515      ld         $gp, offset($sp)
16516
16517    If a register $reg2 was given there, it results in:
16518      daddu      $gp, $reg2, $0  */
16519
16520 static void
16521 s_cpreturn (int ignore ATTRIBUTE_UNUSED)
16522 {
16523   expressionS ex;
16524
16525   /* If we are not generating SVR4 PIC code, .cpreturn is ignored.
16526      We also need NewABI support.  */
16527   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
16528     {
16529       s_ignore (0);
16530       return;
16531     }
16532
16533   macro_start ();
16534   if (mips_cpreturn_register == -1)
16535     {
16536       ex.X_op = O_constant;
16537       ex.X_add_symbol = NULL;
16538       ex.X_op_symbol = NULL;
16539       ex.X_add_number = mips_cpreturn_offset;
16540
16541       macro_build (&ex, "ld", "t,o(b)", mips_gp_register, BFD_RELOC_LO16, SP);
16542     }
16543   else
16544     macro_build (NULL, "daddu", "d,v,t", mips_gp_register,
16545                  mips_cpreturn_register, 0);
16546   macro_end ();
16547
16548   demand_empty_rest_of_line ();
16549 }
16550
16551 /* Handle the .dtprelword and .dtpreldword pseudo-ops.  They generate
16552    a 32-bit or 64-bit DTP-relative relocation (BYTES says which) for
16553    use in DWARF debug information.  */
16554
16555 static void
16556 s_dtprel_internal (size_t bytes)
16557 {
16558   expressionS ex;
16559   char *p;
16560
16561   expression (&ex);
16562
16563   if (ex.X_op != O_symbol)
16564     {
16565       as_bad (_("Unsupported use of %s"), (bytes == 8
16566                                            ? ".dtpreldword"
16567                                            : ".dtprelword"));
16568       ignore_rest_of_line ();
16569     }
16570
16571   p = frag_more (bytes);
16572   md_number_to_chars (p, 0, bytes);
16573   fix_new_exp (frag_now, p - frag_now->fr_literal, bytes, &ex, FALSE,
16574                (bytes == 8
16575                 ? BFD_RELOC_MIPS_TLS_DTPREL64
16576                 : BFD_RELOC_MIPS_TLS_DTPREL32));
16577
16578   demand_empty_rest_of_line ();
16579 }
16580
16581 /* Handle .dtprelword.  */
16582
16583 static void
16584 s_dtprelword (int ignore ATTRIBUTE_UNUSED)
16585 {
16586   s_dtprel_internal (4);
16587 }
16588
16589 /* Handle .dtpreldword.  */
16590
16591 static void
16592 s_dtpreldword (int ignore ATTRIBUTE_UNUSED)
16593 {
16594   s_dtprel_internal (8);
16595 }
16596
16597 /* Handle the .gpvalue pseudo-op.  This is used when generating NewABI PIC
16598    code.  It sets the offset to use in gp_rel relocations.  */
16599
16600 static void
16601 s_gpvalue (int ignore ATTRIBUTE_UNUSED)
16602 {
16603   /* If we are not generating SVR4 PIC code, .gpvalue is ignored.
16604      We also need NewABI support.  */
16605   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
16606     {
16607       s_ignore (0);
16608       return;
16609     }
16610
16611   mips_gprel_offset = get_absolute_expression ();
16612
16613   demand_empty_rest_of_line ();
16614 }
16615
16616 /* Handle the .gpword pseudo-op.  This is used when generating PIC
16617    code.  It generates a 32 bit GP relative reloc.  */
16618
16619 static void
16620 s_gpword (int ignore ATTRIBUTE_UNUSED)
16621 {
16622   segment_info_type *si;
16623   struct insn_label_list *l;
16624   symbolS *label;
16625   expressionS ex;
16626   char *p;
16627
16628   /* When not generating PIC code, this is treated as .word.  */
16629   if (mips_pic != SVR4_PIC)
16630     {
16631       s_cons (2);
16632       return;
16633     }
16634
16635   si = seg_info (now_seg);
16636   l = si->label_list;
16637   label = l != NULL ? l->label : NULL;
16638   mips_emit_delays ();
16639   if (auto_align)
16640     mips_align (2, 0, label);
16641
16642   expression (&ex);
16643   mips_clear_insn_labels ();
16644
16645   if (ex.X_op != O_symbol || ex.X_add_number != 0)
16646     {
16647       as_bad (_("Unsupported use of .gpword"));
16648       ignore_rest_of_line ();
16649     }
16650
16651   p = frag_more (4);
16652   md_number_to_chars (p, 0, 4);
16653   fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &ex, FALSE,
16654                BFD_RELOC_GPREL32);
16655
16656   demand_empty_rest_of_line ();
16657 }
16658
16659 static void
16660 s_gpdword (int ignore ATTRIBUTE_UNUSED)
16661 {
16662   segment_info_type *si;
16663   struct insn_label_list *l;
16664   symbolS *label;
16665   expressionS ex;
16666   char *p;
16667
16668   /* When not generating PIC code, this is treated as .dword.  */
16669   if (mips_pic != SVR4_PIC)
16670     {
16671       s_cons (3);
16672       return;
16673     }
16674
16675   si = seg_info (now_seg);
16676   l = si->label_list;
16677   label = l != NULL ? l->label : NULL;
16678   mips_emit_delays ();
16679   if (auto_align)
16680     mips_align (3, 0, label);
16681
16682   expression (&ex);
16683   mips_clear_insn_labels ();
16684
16685   if (ex.X_op != O_symbol || ex.X_add_number != 0)
16686     {
16687       as_bad (_("Unsupported use of .gpdword"));
16688       ignore_rest_of_line ();
16689     }
16690
16691   p = frag_more (8);
16692   md_number_to_chars (p, 0, 8);
16693   fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &ex, FALSE,
16694                BFD_RELOC_GPREL32)->fx_tcbit = 1;
16695
16696   /* GPREL32 composed with 64 gives a 64-bit GP offset.  */
16697   fix_new (frag_now, p - frag_now->fr_literal, 8, NULL, 0,
16698            FALSE, BFD_RELOC_64)->fx_tcbit = 1;
16699
16700   demand_empty_rest_of_line ();
16701 }
16702
16703 /* Handle the .cpadd pseudo-op.  This is used when dealing with switch
16704    tables in SVR4 PIC code.  */
16705
16706 static void
16707 s_cpadd (int ignore ATTRIBUTE_UNUSED)
16708 {
16709   int reg;
16710
16711   /* This is ignored when not generating SVR4 PIC code.  */
16712   if (mips_pic != SVR4_PIC)
16713     {
16714       s_ignore (0);
16715       return;
16716     }
16717
16718   /* Add $gp to the register named as an argument.  */
16719   macro_start ();
16720   reg = tc_get_register (0);
16721   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", reg, reg, mips_gp_register);
16722   macro_end ();
16723
16724   demand_empty_rest_of_line ();
16725 }
16726
16727 /* Handle the .insn pseudo-op.  This marks instruction labels in
16728    mips16/micromips mode.  This permits the linker to handle them specially,
16729    such as generating jalx instructions when needed.  We also make
16730    them odd for the duration of the assembly, in order to generate the
16731    right sort of code.  We will make them even in the adjust_symtab
16732    routine, while leaving them marked.  This is convenient for the
16733    debugger and the disassembler.  The linker knows to make them odd
16734    again.  */
16735
16736 static void
16737 s_insn (int ignore ATTRIBUTE_UNUSED)
16738 {
16739   mips_mark_labels ();
16740
16741   demand_empty_rest_of_line ();
16742 }
16743
16744 /* Handle a .stabn directive.  We need these in order to mark a label
16745    as being a mips16 text label correctly.  Sometimes the compiler
16746    will emit a label, followed by a .stabn, and then switch sections.
16747    If the label and .stabn are in mips16 mode, then the label is
16748    really a mips16 text label.  */
16749
16750 static void
16751 s_mips_stab (int type)
16752 {
16753   if (type == 'n')
16754     mips_mark_labels ();
16755
16756   s_stab (type);
16757 }
16758
16759 /* Handle the .weakext pseudo-op as defined in Kane and Heinrich.  */
16760
16761 static void
16762 s_mips_weakext (int ignore ATTRIBUTE_UNUSED)
16763 {
16764   char *name;
16765   int c;
16766   symbolS *symbolP;
16767   expressionS exp;
16768
16769   name = input_line_pointer;
16770   c = get_symbol_end ();
16771   symbolP = symbol_find_or_make (name);
16772   S_SET_WEAK (symbolP);
16773   *input_line_pointer = c;
16774
16775   SKIP_WHITESPACE ();
16776
16777   if (! is_end_of_line[(unsigned char) *input_line_pointer])
16778     {
16779       if (S_IS_DEFINED (symbolP))
16780         {
16781           as_bad (_("ignoring attempt to redefine symbol %s"),
16782                   S_GET_NAME (symbolP));
16783           ignore_rest_of_line ();
16784           return;
16785         }
16786
16787       if (*input_line_pointer == ',')
16788         {
16789           ++input_line_pointer;
16790           SKIP_WHITESPACE ();
16791         }
16792
16793       expression (&exp);
16794       if (exp.X_op != O_symbol)
16795         {
16796           as_bad (_("bad .weakext directive"));
16797           ignore_rest_of_line ();
16798           return;
16799         }
16800       symbol_set_value_expression (symbolP, &exp);
16801     }
16802
16803   demand_empty_rest_of_line ();
16804 }
16805
16806 /* Parse a register string into a number.  Called from the ECOFF code
16807    to parse .frame.  The argument is non-zero if this is the frame
16808    register, so that we can record it in mips_frame_reg.  */
16809
16810 int
16811 tc_get_register (int frame)
16812 {
16813   unsigned int reg;
16814
16815   SKIP_WHITESPACE ();
16816   if (! reg_lookup (&input_line_pointer, RWARN | RTYPE_NUM | RTYPE_GP, &reg))
16817     reg = 0;
16818   if (frame)
16819     {
16820       mips_frame_reg = reg != 0 ? reg : SP;
16821       mips_frame_reg_valid = 1;
16822       mips_cprestore_valid = 0;
16823     }
16824   return reg;
16825 }
16826
16827 valueT
16828 md_section_align (asection *seg, valueT addr)
16829 {
16830   int align = bfd_get_section_alignment (stdoutput, seg);
16831
16832   if (IS_ELF)
16833     {
16834       /* We don't need to align ELF sections to the full alignment.
16835          However, Irix 5 may prefer that we align them at least to a 16
16836          byte boundary.  We don't bother to align the sections if we
16837          are targeted for an embedded system.  */
16838       if (strncmp (TARGET_OS, "elf", 3) == 0)
16839         return addr;
16840       if (align > 4)
16841         align = 4;
16842     }
16843
16844   return ((addr + (1 << align) - 1) & (-1 << align));
16845 }
16846
16847 /* Utility routine, called from above as well.  If called while the
16848    input file is still being read, it's only an approximation.  (For
16849    example, a symbol may later become defined which appeared to be
16850    undefined earlier.)  */
16851
16852 static int
16853 nopic_need_relax (symbolS *sym, int before_relaxing)
16854 {
16855   if (sym == 0)
16856     return 0;
16857
16858   if (g_switch_value > 0)
16859     {
16860       const char *symname;
16861       int change;
16862
16863       /* Find out whether this symbol can be referenced off the $gp
16864          register.  It can be if it is smaller than the -G size or if
16865          it is in the .sdata or .sbss section.  Certain symbols can
16866          not be referenced off the $gp, although it appears as though
16867          they can.  */
16868       symname = S_GET_NAME (sym);
16869       if (symname != (const char *) NULL
16870           && (strcmp (symname, "eprol") == 0
16871               || strcmp (symname, "etext") == 0
16872               || strcmp (symname, "_gp") == 0
16873               || strcmp (symname, "edata") == 0
16874               || strcmp (symname, "_fbss") == 0
16875               || strcmp (symname, "_fdata") == 0
16876               || strcmp (symname, "_ftext") == 0
16877               || strcmp (symname, "end") == 0
16878               || strcmp (symname, "_gp_disp") == 0))
16879         change = 1;
16880       else if ((! S_IS_DEFINED (sym) || S_IS_COMMON (sym))
16881                && (0
16882 #ifndef NO_ECOFF_DEBUGGING
16883                    || (symbol_get_obj (sym)->ecoff_extern_size != 0
16884                        && (symbol_get_obj (sym)->ecoff_extern_size
16885                            <= g_switch_value))
16886 #endif
16887                    /* We must defer this decision until after the whole
16888                       file has been read, since there might be a .extern
16889                       after the first use of this symbol.  */
16890                    || (before_relaxing
16891 #ifndef NO_ECOFF_DEBUGGING
16892                        && symbol_get_obj (sym)->ecoff_extern_size == 0
16893 #endif
16894                        && S_GET_VALUE (sym) == 0)
16895                    || (S_GET_VALUE (sym) != 0
16896                        && S_GET_VALUE (sym) <= g_switch_value)))
16897         change = 0;
16898       else
16899         {
16900           const char *segname;
16901
16902           segname = segment_name (S_GET_SEGMENT (sym));
16903           gas_assert (strcmp (segname, ".lit8") != 0
16904                   && strcmp (segname, ".lit4") != 0);
16905           change = (strcmp (segname, ".sdata") != 0
16906                     && strcmp (segname, ".sbss") != 0
16907                     && strncmp (segname, ".sdata.", 7) != 0
16908                     && strncmp (segname, ".sbss.", 6) != 0
16909                     && strncmp (segname, ".gnu.linkonce.sb.", 17) != 0
16910                     && strncmp (segname, ".gnu.linkonce.s.", 16) != 0);
16911         }
16912       return change;
16913     }
16914   else
16915     /* We are not optimizing for the $gp register.  */
16916     return 1;
16917 }
16918
16919
16920 /* Return true if the given symbol should be considered local for SVR4 PIC.  */
16921
16922 static bfd_boolean
16923 pic_need_relax (symbolS *sym, asection *segtype)
16924 {
16925   asection *symsec;
16926
16927   /* Handle the case of a symbol equated to another symbol.  */
16928   while (symbol_equated_reloc_p (sym))
16929     {
16930       symbolS *n;
16931
16932       /* It's possible to get a loop here in a badly written program.  */
16933       n = symbol_get_value_expression (sym)->X_add_symbol;
16934       if (n == sym)
16935         break;
16936       sym = n;
16937     }
16938
16939   if (symbol_section_p (sym))
16940     return TRUE;
16941
16942   symsec = S_GET_SEGMENT (sym);
16943
16944   /* This must duplicate the test in adjust_reloc_syms.  */
16945   return (symsec != &bfd_und_section
16946           && symsec != &bfd_abs_section
16947           && !bfd_is_com_section (symsec)
16948           && !s_is_linkonce (sym, segtype)
16949 #ifdef OBJ_ELF
16950           /* A global or weak symbol is treated as external.  */
16951           && (!IS_ELF || (! S_IS_WEAK (sym) && ! S_IS_EXTERNAL (sym)))
16952 #endif
16953           );
16954 }
16955
16956
16957 /* Given a mips16 variant frag FRAGP, return non-zero if it needs an
16958    extended opcode.  SEC is the section the frag is in.  */
16959
16960 static int
16961 mips16_extended_frag (fragS *fragp, asection *sec, long stretch)
16962 {
16963   int type;
16964   const struct mips16_immed_operand *op;
16965   offsetT val;
16966   int mintiny, maxtiny;
16967   segT symsec;
16968   fragS *sym_frag;
16969
16970   if (RELAX_MIPS16_USER_SMALL (fragp->fr_subtype))
16971     return 0;
16972   if (RELAX_MIPS16_USER_EXT (fragp->fr_subtype))
16973     return 1;
16974
16975   type = RELAX_MIPS16_TYPE (fragp->fr_subtype);
16976   op = mips16_immed_operands;
16977   while (op->type != type)
16978     {
16979       ++op;
16980       gas_assert (op < mips16_immed_operands + MIPS16_NUM_IMMED);
16981     }
16982
16983   if (op->unsp)
16984     {
16985       if (type == '<' || type == '>' || type == '[' || type == ']')
16986         {
16987           mintiny = 1;
16988           maxtiny = 1 << op->nbits;
16989         }
16990       else
16991         {
16992           mintiny = 0;
16993           maxtiny = (1 << op->nbits) - 1;
16994         }
16995     }
16996   else
16997     {
16998       mintiny = - (1 << (op->nbits - 1));
16999       maxtiny = (1 << (op->nbits - 1)) - 1;
17000     }
17001
17002   sym_frag = symbol_get_frag (fragp->fr_symbol);
17003   val = S_GET_VALUE (fragp->fr_symbol);
17004   symsec = S_GET_SEGMENT (fragp->fr_symbol);
17005
17006   if (op->pcrel)
17007     {
17008       addressT addr;
17009
17010       /* We won't have the section when we are called from
17011          mips_relax_frag.  However, we will always have been called
17012          from md_estimate_size_before_relax first.  If this is a
17013          branch to a different section, we mark it as such.  If SEC is
17014          NULL, and the frag is not marked, then it must be a branch to
17015          the same section.  */
17016       if (sec == NULL)
17017         {
17018           if (RELAX_MIPS16_LONG_BRANCH (fragp->fr_subtype))
17019             return 1;
17020         }
17021       else
17022         {
17023           /* Must have been called from md_estimate_size_before_relax.  */
17024           if (symsec != sec)
17025             {
17026               fragp->fr_subtype =
17027                 RELAX_MIPS16_MARK_LONG_BRANCH (fragp->fr_subtype);
17028
17029               /* FIXME: We should support this, and let the linker
17030                  catch branches and loads that are out of range.  */
17031               as_bad_where (fragp->fr_file, fragp->fr_line,
17032                             _("unsupported PC relative reference to different section"));
17033
17034               return 1;
17035             }
17036           if (fragp != sym_frag && sym_frag->fr_address == 0)
17037             /* Assume non-extended on the first relaxation pass.
17038                The address we have calculated will be bogus if this is
17039                a forward branch to another frag, as the forward frag
17040                will have fr_address == 0.  */
17041             return 0;
17042         }
17043
17044       /* In this case, we know for sure that the symbol fragment is in
17045          the same section.  If the relax_marker of the symbol fragment
17046          differs from the relax_marker of this fragment, we have not
17047          yet adjusted the symbol fragment fr_address.  We want to add
17048          in STRETCH in order to get a better estimate of the address.
17049          This particularly matters because of the shift bits.  */
17050       if (stretch != 0
17051           && sym_frag->relax_marker != fragp->relax_marker)
17052         {
17053           fragS *f;
17054
17055           /* Adjust stretch for any alignment frag.  Note that if have
17056              been expanding the earlier code, the symbol may be
17057              defined in what appears to be an earlier frag.  FIXME:
17058              This doesn't handle the fr_subtype field, which specifies
17059              a maximum number of bytes to skip when doing an
17060              alignment.  */
17061           for (f = fragp; f != NULL && f != sym_frag; f = f->fr_next)
17062             {
17063               if (f->fr_type == rs_align || f->fr_type == rs_align_code)
17064                 {
17065                   if (stretch < 0)
17066                     stretch = - ((- stretch)
17067                                  & ~ ((1 << (int) f->fr_offset) - 1));
17068                   else
17069                     stretch &= ~ ((1 << (int) f->fr_offset) - 1);
17070                   if (stretch == 0)
17071                     break;
17072                 }
17073             }
17074           if (f != NULL)
17075             val += stretch;
17076         }
17077
17078       addr = fragp->fr_address + fragp->fr_fix;
17079
17080       /* The base address rules are complicated.  The base address of
17081          a branch is the following instruction.  The base address of a
17082          PC relative load or add is the instruction itself, but if it
17083          is in a delay slot (in which case it can not be extended) use
17084          the address of the instruction whose delay slot it is in.  */
17085       if (type == 'p' || type == 'q')
17086         {
17087           addr += 2;
17088
17089           /* If we are currently assuming that this frag should be
17090              extended, then, the current address is two bytes
17091              higher.  */
17092           if (RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
17093             addr += 2;
17094
17095           /* Ignore the low bit in the target, since it will be set
17096              for a text label.  */
17097           if ((val & 1) != 0)
17098             --val;
17099         }
17100       else if (RELAX_MIPS16_JAL_DSLOT (fragp->fr_subtype))
17101         addr -= 4;
17102       else if (RELAX_MIPS16_DSLOT (fragp->fr_subtype))
17103         addr -= 2;
17104
17105       val -= addr & ~ ((1 << op->shift) - 1);
17106
17107       /* Branch offsets have an implicit 0 in the lowest bit.  */
17108       if (type == 'p' || type == 'q')
17109         val /= 2;
17110
17111       /* If any of the shifted bits are set, we must use an extended
17112          opcode.  If the address depends on the size of this
17113          instruction, this can lead to a loop, so we arrange to always
17114          use an extended opcode.  We only check this when we are in
17115          the main relaxation loop, when SEC is NULL.  */
17116       if ((val & ((1 << op->shift) - 1)) != 0 && sec == NULL)
17117         {
17118           fragp->fr_subtype =
17119             RELAX_MIPS16_MARK_LONG_BRANCH (fragp->fr_subtype);
17120           return 1;
17121         }
17122
17123       /* If we are about to mark a frag as extended because the value
17124          is precisely maxtiny + 1, then there is a chance of an
17125          infinite loop as in the following code:
17126              la $4,foo
17127              .skip      1020
17128              .align     2
17129            foo:
17130          In this case when the la is extended, foo is 0x3fc bytes
17131          away, so the la can be shrunk, but then foo is 0x400 away, so
17132          the la must be extended.  To avoid this loop, we mark the
17133          frag as extended if it was small, and is about to become
17134          extended with a value of maxtiny + 1.  */
17135       if (val == ((maxtiny + 1) << op->shift)
17136           && ! RELAX_MIPS16_EXTENDED (fragp->fr_subtype)
17137           && sec == NULL)
17138         {
17139           fragp->fr_subtype =
17140             RELAX_MIPS16_MARK_LONG_BRANCH (fragp->fr_subtype);
17141           return 1;
17142         }
17143     }
17144   else if (symsec != absolute_section && sec != NULL)
17145     as_bad_where (fragp->fr_file, fragp->fr_line, _("unsupported relocation"));
17146
17147   if ((val & ((1 << op->shift) - 1)) != 0
17148       || val < (mintiny << op->shift)
17149       || val > (maxtiny << op->shift))
17150     return 1;
17151   else
17152     return 0;
17153 }
17154
17155 /* Compute the length of a branch sequence, and adjust the
17156    RELAX_BRANCH_TOOFAR bit accordingly.  If FRAGP is NULL, the
17157    worst-case length is computed, with UPDATE being used to indicate
17158    whether an unconditional (-1), branch-likely (+1) or regular (0)
17159    branch is to be computed.  */
17160 static int
17161 relaxed_branch_length (fragS *fragp, asection *sec, int update)
17162 {
17163   bfd_boolean toofar;
17164   int length;
17165
17166   if (fragp
17167       && S_IS_DEFINED (fragp->fr_symbol)
17168       && sec == S_GET_SEGMENT (fragp->fr_symbol))
17169     {
17170       addressT addr;
17171       offsetT val;
17172
17173       val = S_GET_VALUE (fragp->fr_symbol) + fragp->fr_offset;
17174
17175       addr = fragp->fr_address + fragp->fr_fix + 4;
17176
17177       val -= addr;
17178
17179       toofar = val < - (0x8000 << 2) || val >= (0x8000 << 2);
17180     }
17181   else if (fragp)
17182     /* If the symbol is not defined or it's in a different segment,
17183        assume the user knows what's going on and emit a short
17184        branch.  */
17185     toofar = FALSE;
17186   else
17187     toofar = TRUE;
17188
17189   if (fragp && update && toofar != RELAX_BRANCH_TOOFAR (fragp->fr_subtype))
17190     fragp->fr_subtype
17191       = RELAX_BRANCH_ENCODE (RELAX_BRANCH_AT (fragp->fr_subtype),
17192                              RELAX_BRANCH_UNCOND (fragp->fr_subtype),
17193                              RELAX_BRANCH_LIKELY (fragp->fr_subtype),
17194                              RELAX_BRANCH_LINK (fragp->fr_subtype),
17195                              toofar);
17196
17197   length = 4;
17198   if (toofar)
17199     {
17200       if (fragp ? RELAX_BRANCH_LIKELY (fragp->fr_subtype) : (update > 0))
17201         length += 8;
17202
17203       if (mips_pic != NO_PIC)
17204         {
17205           /* Additional space for PIC loading of target address.  */
17206           length += 8;
17207           if (mips_opts.isa == ISA_MIPS1)
17208             /* Additional space for $at-stabilizing nop.  */
17209             length += 4;
17210         }
17211
17212       /* If branch is conditional.  */
17213       if (fragp ? !RELAX_BRANCH_UNCOND (fragp->fr_subtype) : (update >= 0))
17214         length += 8;
17215     }
17216
17217   return length;
17218 }
17219
17220 /* Compute the length of a branch sequence, and adjust the
17221    RELAX_MICROMIPS_TOOFAR32 bit accordingly.  If FRAGP is NULL, the
17222    worst-case length is computed, with UPDATE being used to indicate
17223    whether an unconditional (-1), or regular (0) branch is to be
17224    computed.  */
17225
17226 static int
17227 relaxed_micromips_32bit_branch_length (fragS *fragp, asection *sec, int update)
17228 {
17229   bfd_boolean toofar;
17230   int length;
17231
17232   if (fragp
17233       && S_IS_DEFINED (fragp->fr_symbol)
17234       && sec == S_GET_SEGMENT (fragp->fr_symbol))
17235     {
17236       addressT addr;
17237       offsetT val;
17238
17239       val = S_GET_VALUE (fragp->fr_symbol) + fragp->fr_offset;
17240       /* Ignore the low bit in the target, since it will be set
17241          for a text label.  */
17242       if ((val & 1) != 0)
17243         --val;
17244
17245       addr = fragp->fr_address + fragp->fr_fix + 4;
17246
17247       val -= addr;
17248
17249       toofar = val < - (0x8000 << 1) || val >= (0x8000 << 1);
17250     }
17251   else if (fragp)
17252     /* If the symbol is not defined or it's in a different segment,
17253        assume the user knows what's going on and emit a short
17254        branch.  */
17255     toofar = FALSE;
17256   else
17257     toofar = TRUE;
17258
17259   if (fragp && update
17260       && toofar != RELAX_MICROMIPS_TOOFAR32 (fragp->fr_subtype))
17261     fragp->fr_subtype = (toofar
17262                          ? RELAX_MICROMIPS_MARK_TOOFAR32 (fragp->fr_subtype)
17263                          : RELAX_MICROMIPS_CLEAR_TOOFAR32 (fragp->fr_subtype));
17264
17265   length = 4;
17266   if (toofar)
17267     {
17268       bfd_boolean compact_known = fragp != NULL;
17269       bfd_boolean compact = FALSE;
17270       bfd_boolean uncond;
17271
17272       if (compact_known)
17273         compact = RELAX_MICROMIPS_COMPACT (fragp->fr_subtype);
17274       if (fragp)
17275         uncond = RELAX_MICROMIPS_UNCOND (fragp->fr_subtype);
17276       else
17277         uncond = update < 0;
17278
17279       /* If label is out of range, we turn branch <br>:
17280
17281                 <br>    label                   # 4 bytes
17282             0:
17283
17284          into:
17285
17286                 j       label                   # 4 bytes
17287                 nop                             # 2 bytes if compact && !PIC
17288             0:
17289        */
17290       if (mips_pic == NO_PIC && (!compact_known || compact))
17291         length += 2;
17292
17293       /* If assembling PIC code, we further turn:
17294
17295                         j       label                   # 4 bytes
17296
17297          into:
17298
17299                         lw/ld   at, %got(label)(gp)     # 4 bytes
17300                         d/addiu at, %lo(label)          # 4 bytes
17301                         jr/c    at                      # 2 bytes
17302        */
17303       if (mips_pic != NO_PIC)
17304         length += 6;
17305
17306       /* If branch <br> is conditional, we prepend negated branch <brneg>:
17307
17308                         <brneg> 0f                      # 4 bytes
17309                         nop                             # 2 bytes if !compact
17310        */
17311       if (!uncond)
17312         length += (compact_known && compact) ? 4 : 6;
17313     }
17314
17315   return length;
17316 }
17317
17318 /* Compute the length of a branch, and adjust the RELAX_MICROMIPS_TOOFAR16
17319    bit accordingly.  */
17320
17321 static int
17322 relaxed_micromips_16bit_branch_length (fragS *fragp, asection *sec, int update)
17323 {
17324   bfd_boolean toofar;
17325
17326   if (fragp
17327       && S_IS_DEFINED (fragp->fr_symbol)
17328       && sec == S_GET_SEGMENT (fragp->fr_symbol))
17329     {
17330       addressT addr;
17331       offsetT val;
17332       int type;
17333
17334       val = S_GET_VALUE (fragp->fr_symbol) + fragp->fr_offset;
17335       /* Ignore the low bit in the target, since it will be set
17336          for a text label.  */
17337       if ((val & 1) != 0)
17338         --val;
17339
17340       /* Assume this is a 2-byte branch.  */
17341       addr = fragp->fr_address + fragp->fr_fix + 2;
17342
17343       /* We try to avoid the infinite loop by not adding 2 more bytes for
17344          long branches.  */
17345
17346       val -= addr;
17347
17348       type = RELAX_MICROMIPS_TYPE (fragp->fr_subtype);
17349       if (type == 'D')
17350         toofar = val < - (0x200 << 1) || val >= (0x200 << 1);
17351       else if (type == 'E')
17352         toofar = val < - (0x40 << 1) || val >= (0x40 << 1);
17353       else
17354         abort ();
17355     }
17356   else
17357     /* If the symbol is not defined or it's in a different segment,
17358        we emit a normal 32-bit branch.  */
17359     toofar = TRUE;
17360
17361   if (fragp && update
17362       && toofar != RELAX_MICROMIPS_TOOFAR16 (fragp->fr_subtype))
17363     fragp->fr_subtype
17364       = toofar ? RELAX_MICROMIPS_MARK_TOOFAR16 (fragp->fr_subtype)
17365                : RELAX_MICROMIPS_CLEAR_TOOFAR16 (fragp->fr_subtype);
17366
17367   if (toofar)
17368     return 4;
17369
17370   return 2;
17371 }
17372
17373 /* Estimate the size of a frag before relaxing.  Unless this is the
17374    mips16, we are not really relaxing here, and the final size is
17375    encoded in the subtype information.  For the mips16, we have to
17376    decide whether we are using an extended opcode or not.  */
17377
17378 int
17379 md_estimate_size_before_relax (fragS *fragp, asection *segtype)
17380 {
17381   int change;
17382
17383   if (RELAX_BRANCH_P (fragp->fr_subtype))
17384     {
17385
17386       fragp->fr_var = relaxed_branch_length (fragp, segtype, FALSE);
17387
17388       return fragp->fr_var;
17389     }
17390
17391   if (RELAX_MIPS16_P (fragp->fr_subtype))
17392     /* We don't want to modify the EXTENDED bit here; it might get us
17393        into infinite loops.  We change it only in mips_relax_frag().  */
17394     return (RELAX_MIPS16_EXTENDED (fragp->fr_subtype) ? 4 : 2);
17395
17396   if (RELAX_MICROMIPS_P (fragp->fr_subtype))
17397     {
17398       int length = 4;
17399
17400       if (RELAX_MICROMIPS_TYPE (fragp->fr_subtype) != 0)
17401         length = relaxed_micromips_16bit_branch_length (fragp, segtype, FALSE);
17402       if (length == 4 && RELAX_MICROMIPS_RELAX32 (fragp->fr_subtype))
17403         length = relaxed_micromips_32bit_branch_length (fragp, segtype, FALSE);
17404       fragp->fr_var = length;
17405
17406       return length;
17407     }
17408
17409   if (mips_pic == NO_PIC)
17410     change = nopic_need_relax (fragp->fr_symbol, 0);
17411   else if (mips_pic == SVR4_PIC)
17412     change = pic_need_relax (fragp->fr_symbol, segtype);
17413   else if (mips_pic == VXWORKS_PIC)
17414     /* For vxworks, GOT16 relocations never have a corresponding LO16.  */
17415     change = 0;
17416   else
17417     abort ();
17418
17419   if (change)
17420     {
17421       fragp->fr_subtype |= RELAX_USE_SECOND;
17422       return -RELAX_FIRST (fragp->fr_subtype);
17423     }
17424   else
17425     return -RELAX_SECOND (fragp->fr_subtype);
17426 }
17427
17428 /* This is called to see whether a reloc against a defined symbol
17429    should be converted into a reloc against a section.  */
17430
17431 int
17432 mips_fix_adjustable (fixS *fixp)
17433 {
17434   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
17435       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
17436     return 0;
17437
17438   if (fixp->fx_addsy == NULL)
17439     return 1;
17440
17441   /* If symbol SYM is in a mergeable section, relocations of the form
17442      SYM + 0 can usually be made section-relative.  The mergeable data
17443      is then identified by the section offset rather than by the symbol.
17444
17445      However, if we're generating REL LO16 relocations, the offset is split
17446      between the LO16 and parterning high part relocation.  The linker will
17447      need to recalculate the complete offset in order to correctly identify
17448      the merge data.
17449
17450      The linker has traditionally not looked for the parterning high part
17451      relocation, and has thus allowed orphaned R_MIPS_LO16 relocations to be
17452      placed anywhere.  Rather than break backwards compatibility by changing
17453      this, it seems better not to force the issue, and instead keep the
17454      original symbol.  This will work with either linker behavior.  */
17455   if ((lo16_reloc_p (fixp->fx_r_type)
17456        || reloc_needs_lo_p (fixp->fx_r_type))
17457       && HAVE_IN_PLACE_ADDENDS
17458       && (S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_MERGE) != 0)
17459     return 0;
17460
17461   /* There is no place to store an in-place offset for JALR relocations.
17462      Likewise an in-range offset of PC-relative relocations may overflow
17463      the in-place relocatable field if recalculated against the start
17464      address of the symbol's containing section.  */
17465   if (HAVE_IN_PLACE_ADDENDS
17466       && (fixp->fx_pcrel || jalr_reloc_p (fixp->fx_r_type)))
17467     return 0;
17468
17469 #ifdef OBJ_ELF
17470   /* R_MIPS16_26 relocations against non-MIPS16 functions might resolve
17471      to a floating-point stub.  The same is true for non-R_MIPS16_26
17472      relocations against MIPS16 functions; in this case, the stub becomes
17473      the function's canonical address.
17474
17475      Floating-point stubs are stored in unique .mips16.call.* or
17476      .mips16.fn.* sections.  If a stub T for function F is in section S,
17477      the first relocation in section S must be against F; this is how the
17478      linker determines the target function.  All relocations that might
17479      resolve to T must also be against F.  We therefore have the following
17480      restrictions, which are given in an intentionally-redundant way:
17481
17482        1. We cannot reduce R_MIPS16_26 relocations against non-MIPS16
17483           symbols.
17484
17485        2. We cannot reduce a stub's relocations against non-MIPS16 symbols
17486           if that stub might be used.
17487
17488        3. We cannot reduce non-R_MIPS16_26 relocations against MIPS16
17489           symbols.
17490
17491        4. We cannot reduce a stub's relocations against MIPS16 symbols if
17492           that stub might be used.
17493
17494      There is a further restriction:
17495
17496        5. We cannot reduce jump relocations (R_MIPS_26, R_MIPS16_26 or
17497           R_MICROMIPS_26_S1) against MIPS16 or microMIPS symbols on
17498           targets with in-place addends; the relocation field cannot
17499           encode the low bit.
17500
17501      For simplicity, we deal with (3)-(4) by not reducing _any_ relocation
17502      against a MIPS16 symbol.  We deal with (5) by by not reducing any
17503      such relocations on REL targets.
17504
17505      We deal with (1)-(2) by saying that, if there's a R_MIPS16_26
17506      relocation against some symbol R, no relocation against R may be
17507      reduced.  (Note that this deals with (2) as well as (1) because
17508      relocations against global symbols will never be reduced on ELF
17509      targets.)  This approach is a little simpler than trying to detect
17510      stub sections, and gives the "all or nothing" per-symbol consistency
17511      that we have for MIPS16 symbols.  */
17512   if (IS_ELF
17513       && fixp->fx_subsy == NULL
17514       && (ELF_ST_IS_MIPS16 (S_GET_OTHER (fixp->fx_addsy))
17515           || *symbol_get_tc (fixp->fx_addsy)
17516           || (HAVE_IN_PLACE_ADDENDS
17517               && ELF_ST_IS_MICROMIPS (S_GET_OTHER (fixp->fx_addsy))
17518               && jmp_reloc_p (fixp->fx_r_type))))
17519     return 0;
17520 #endif
17521
17522   return 1;
17523 }
17524
17525 /* Translate internal representation of relocation info to BFD target
17526    format.  */
17527
17528 arelent **
17529 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
17530 {
17531   static arelent *retval[4];
17532   arelent *reloc;
17533   bfd_reloc_code_real_type code;
17534
17535   memset (retval, 0, sizeof(retval));
17536   reloc = retval[0] = (arelent *) xcalloc (1, sizeof (arelent));
17537   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
17538   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
17539   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
17540
17541   if (fixp->fx_pcrel)
17542     {
17543       gas_assert (fixp->fx_r_type == BFD_RELOC_16_PCREL_S2
17544                   || fixp->fx_r_type == BFD_RELOC_MICROMIPS_7_PCREL_S1
17545                   || fixp->fx_r_type == BFD_RELOC_MICROMIPS_10_PCREL_S1
17546                   || fixp->fx_r_type == BFD_RELOC_MICROMIPS_16_PCREL_S1);
17547
17548       /* At this point, fx_addnumber is "symbol offset - pcrel address".
17549          Relocations want only the symbol offset.  */
17550       reloc->addend = fixp->fx_addnumber + reloc->address;
17551       if (!IS_ELF)
17552         {
17553           /* A gruesome hack which is a result of the gruesome gas
17554              reloc handling.  What's worse, for COFF (as opposed to
17555              ECOFF), we might need yet another copy of reloc->address.
17556              See bfd_install_relocation.  */
17557           reloc->addend += reloc->address;
17558         }
17559     }
17560   else
17561     reloc->addend = fixp->fx_addnumber;
17562
17563   /* Since the old MIPS ELF ABI uses Rel instead of Rela, encode the vtable
17564      entry to be used in the relocation's section offset.  */
17565   if (! HAVE_NEWABI && fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
17566     {
17567       reloc->address = reloc->addend;
17568       reloc->addend = 0;
17569     }
17570
17571   code = fixp->fx_r_type;
17572
17573   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
17574   if (reloc->howto == NULL)
17575     {
17576       as_bad_where (fixp->fx_file, fixp->fx_line,
17577                     _("Can not represent %s relocation in this object file format"),
17578                     bfd_get_reloc_code_name (code));
17579       retval[0] = NULL;
17580     }
17581
17582   return retval;
17583 }
17584
17585 /* Relax a machine dependent frag.  This returns the amount by which
17586    the current size of the frag should change.  */
17587
17588 int
17589 mips_relax_frag (asection *sec, fragS *fragp, long stretch)
17590 {
17591   if (RELAX_BRANCH_P (fragp->fr_subtype))
17592     {
17593       offsetT old_var = fragp->fr_var;
17594
17595       fragp->fr_var = relaxed_branch_length (fragp, sec, TRUE);
17596
17597       return fragp->fr_var - old_var;
17598     }
17599
17600   if (RELAX_MICROMIPS_P (fragp->fr_subtype))
17601     {
17602       offsetT old_var = fragp->fr_var;
17603       offsetT new_var = 4;
17604
17605       if (RELAX_MICROMIPS_TYPE (fragp->fr_subtype) != 0)
17606         new_var = relaxed_micromips_16bit_branch_length (fragp, sec, TRUE);
17607       if (new_var == 4 && RELAX_MICROMIPS_RELAX32 (fragp->fr_subtype))
17608         new_var = relaxed_micromips_32bit_branch_length (fragp, sec, TRUE);
17609       fragp->fr_var = new_var;
17610
17611       return new_var - old_var;
17612     }
17613
17614   if (! RELAX_MIPS16_P (fragp->fr_subtype))
17615     return 0;
17616
17617   if (mips16_extended_frag (fragp, NULL, stretch))
17618     {
17619       if (RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
17620         return 0;
17621       fragp->fr_subtype = RELAX_MIPS16_MARK_EXTENDED (fragp->fr_subtype);
17622       return 2;
17623     }
17624   else
17625     {
17626       if (! RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
17627         return 0;
17628       fragp->fr_subtype = RELAX_MIPS16_CLEAR_EXTENDED (fragp->fr_subtype);
17629       return -2;
17630     }
17631
17632   return 0;
17633 }
17634
17635 /* Convert a machine dependent frag.  */
17636
17637 void
17638 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT asec, fragS *fragp)
17639 {
17640   if (RELAX_BRANCH_P (fragp->fr_subtype))
17641     {
17642       bfd_byte *buf;
17643       unsigned long insn;
17644       expressionS exp;
17645       fixS *fixp;
17646
17647       buf = (bfd_byte *)fragp->fr_literal + fragp->fr_fix;
17648
17649       if (target_big_endian)
17650         insn = bfd_getb32 (buf);
17651       else
17652         insn = bfd_getl32 (buf);
17653
17654       if (!RELAX_BRANCH_TOOFAR (fragp->fr_subtype))
17655         {
17656           /* We generate a fixup instead of applying it right now
17657              because, if there are linker relaxations, we're going to
17658              need the relocations.  */
17659           exp.X_op = O_symbol;
17660           exp.X_add_symbol = fragp->fr_symbol;
17661           exp.X_add_number = fragp->fr_offset;
17662
17663           fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
17664                               4, &exp, TRUE, BFD_RELOC_16_PCREL_S2);
17665           fixp->fx_file = fragp->fr_file;
17666           fixp->fx_line = fragp->fr_line;
17667
17668           md_number_to_chars ((char *) buf, insn, 4);
17669           buf += 4;
17670         }
17671       else
17672         {
17673           int i;
17674
17675           as_warn_where (fragp->fr_file, fragp->fr_line,
17676                          _("Relaxed out-of-range branch into a jump"));
17677
17678           if (RELAX_BRANCH_UNCOND (fragp->fr_subtype))
17679             goto uncond;
17680
17681           if (!RELAX_BRANCH_LIKELY (fragp->fr_subtype))
17682             {
17683               /* Reverse the branch.  */
17684               switch ((insn >> 28) & 0xf)
17685                 {
17686                 case 4:
17687                   /* bc[0-3][tf]l? and bc1any[24][ft] instructions can
17688                      have the condition reversed by tweaking a single
17689                      bit, and their opcodes all have 0x4???????.  */
17690                   gas_assert ((insn & 0xf1000000) == 0x41000000);
17691                   insn ^= 0x00010000;
17692                   break;
17693
17694                 case 0:
17695                   /* bltz       0x04000000      bgez    0x04010000
17696                      bltzal     0x04100000      bgezal  0x04110000  */
17697                   gas_assert ((insn & 0xfc0e0000) == 0x04000000);
17698                   insn ^= 0x00010000;
17699                   break;
17700
17701                 case 1:
17702                   /* beq        0x10000000      bne     0x14000000
17703                      blez       0x18000000      bgtz    0x1c000000  */
17704                   insn ^= 0x04000000;
17705                   break;
17706
17707                 default:
17708                   abort ();
17709                 }
17710             }
17711
17712           if (RELAX_BRANCH_LINK (fragp->fr_subtype))
17713             {
17714               /* Clear the and-link bit.  */
17715               gas_assert ((insn & 0xfc1c0000) == 0x04100000);
17716
17717               /* bltzal         0x04100000      bgezal  0x04110000
17718                  bltzall        0x04120000      bgezall 0x04130000  */
17719               insn &= ~0x00100000;
17720             }
17721
17722           /* Branch over the branch (if the branch was likely) or the
17723              full jump (not likely case).  Compute the offset from the
17724              current instruction to branch to.  */
17725           if (RELAX_BRANCH_LIKELY (fragp->fr_subtype))
17726             i = 16;
17727           else
17728             {
17729               /* How many bytes in instructions we've already emitted?  */
17730               i = buf - (bfd_byte *)fragp->fr_literal - fragp->fr_fix;
17731               /* How many bytes in instructions from here to the end?  */
17732               i = fragp->fr_var - i;
17733             }
17734           /* Convert to instruction count.  */
17735           i >>= 2;
17736           /* Branch counts from the next instruction.  */
17737           i--;
17738           insn |= i;
17739           /* Branch over the jump.  */
17740           md_number_to_chars ((char *) buf, insn, 4);
17741           buf += 4;
17742
17743           /* nop */
17744           md_number_to_chars ((char *) buf, 0, 4);
17745           buf += 4;
17746
17747           if (RELAX_BRANCH_LIKELY (fragp->fr_subtype))
17748             {
17749               /* beql $0, $0, 2f */
17750               insn = 0x50000000;
17751               /* Compute the PC offset from the current instruction to
17752                  the end of the variable frag.  */
17753               /* How many bytes in instructions we've already emitted?  */
17754               i = buf - (bfd_byte *)fragp->fr_literal - fragp->fr_fix;
17755               /* How many bytes in instructions from here to the end?  */
17756               i = fragp->fr_var - i;
17757               /* Convert to instruction count.  */
17758               i >>= 2;
17759               /* Don't decrement i, because we want to branch over the
17760                  delay slot.  */
17761
17762               insn |= i;
17763               md_number_to_chars ((char *) buf, insn, 4);
17764               buf += 4;
17765
17766               md_number_to_chars ((char *) buf, 0, 4);
17767               buf += 4;
17768             }
17769
17770         uncond:
17771           if (mips_pic == NO_PIC)
17772             {
17773               /* j or jal.  */
17774               insn = (RELAX_BRANCH_LINK (fragp->fr_subtype)
17775                       ? 0x0c000000 : 0x08000000);
17776               exp.X_op = O_symbol;
17777               exp.X_add_symbol = fragp->fr_symbol;
17778               exp.X_add_number = fragp->fr_offset;
17779
17780               fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
17781                                   4, &exp, FALSE, BFD_RELOC_MIPS_JMP);
17782               fixp->fx_file = fragp->fr_file;
17783               fixp->fx_line = fragp->fr_line;
17784
17785               md_number_to_chars ((char *) buf, insn, 4);
17786               buf += 4;
17787             }
17788           else
17789             {
17790               unsigned long at = RELAX_BRANCH_AT (fragp->fr_subtype);
17791
17792               /* lw/ld $at, <sym>($gp)  R_MIPS_GOT16 */
17793               insn = HAVE_64BIT_ADDRESSES ? 0xdf800000 : 0x8f800000;
17794               insn |= at << OP_SH_RT;
17795               exp.X_op = O_symbol;
17796               exp.X_add_symbol = fragp->fr_symbol;
17797               exp.X_add_number = fragp->fr_offset;
17798
17799               if (fragp->fr_offset)
17800                 {
17801                   exp.X_add_symbol = make_expr_symbol (&exp);
17802                   exp.X_add_number = 0;
17803                 }
17804
17805               fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
17806                                   4, &exp, FALSE, BFD_RELOC_MIPS_GOT16);
17807               fixp->fx_file = fragp->fr_file;
17808               fixp->fx_line = fragp->fr_line;
17809
17810               md_number_to_chars ((char *) buf, insn, 4);
17811               buf += 4;
17812
17813               if (mips_opts.isa == ISA_MIPS1)
17814                 {
17815                   /* nop */
17816                   md_number_to_chars ((char *) buf, 0, 4);
17817                   buf += 4;
17818                 }
17819
17820               /* d/addiu $at, $at, <sym>  R_MIPS_LO16 */
17821               insn = HAVE_64BIT_ADDRESSES ? 0x64000000 : 0x24000000;
17822               insn |= at << OP_SH_RS | at << OP_SH_RT;
17823
17824               fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
17825                                   4, &exp, FALSE, BFD_RELOC_LO16);
17826               fixp->fx_file = fragp->fr_file;
17827               fixp->fx_line = fragp->fr_line;
17828
17829               md_number_to_chars ((char *) buf, insn, 4);
17830               buf += 4;
17831
17832               /* j(al)r $at.  */
17833               if (RELAX_BRANCH_LINK (fragp->fr_subtype))
17834                 insn = 0x0000f809;
17835               else
17836                 insn = 0x00000008;
17837               insn |= at << OP_SH_RS;
17838
17839               md_number_to_chars ((char *) buf, insn, 4);
17840               buf += 4;
17841             }
17842         }
17843
17844       gas_assert (buf == (bfd_byte *)fragp->fr_literal
17845               + fragp->fr_fix + fragp->fr_var);
17846
17847       fragp->fr_fix += fragp->fr_var;
17848
17849       return;
17850     }
17851
17852   /* Relax microMIPS branches.  */
17853   if (RELAX_MICROMIPS_P (fragp->fr_subtype))
17854     {
17855       bfd_byte *buf = (bfd_byte *) (fragp->fr_literal + fragp->fr_fix);
17856       bfd_boolean compact = RELAX_MICROMIPS_COMPACT (fragp->fr_subtype);
17857       bfd_boolean al = RELAX_MICROMIPS_LINK (fragp->fr_subtype);
17858       int type = RELAX_MICROMIPS_TYPE (fragp->fr_subtype);
17859       bfd_boolean short_ds;
17860       unsigned long insn;
17861       expressionS exp;
17862       fixS *fixp;
17863
17864       exp.X_op = O_symbol;
17865       exp.X_add_symbol = fragp->fr_symbol;
17866       exp.X_add_number = fragp->fr_offset;
17867
17868       fragp->fr_fix += fragp->fr_var;
17869
17870       /* Handle 16-bit branches that fit or are forced to fit.  */
17871       if (type != 0 && !RELAX_MICROMIPS_TOOFAR16 (fragp->fr_subtype))
17872         {
17873           /* We generate a fixup instead of applying it right now,
17874              because if there is linker relaxation, we're going to
17875              need the relocations.  */
17876           if (type == 'D')
17877             fixp = fix_new_exp (fragp,
17878                                 buf - (bfd_byte *) fragp->fr_literal,
17879                                 2, &exp, TRUE,
17880                                 BFD_RELOC_MICROMIPS_10_PCREL_S1);
17881           else if (type == 'E')
17882             fixp = fix_new_exp (fragp,
17883                                 buf - (bfd_byte *) fragp->fr_literal,
17884                                 2, &exp, TRUE,
17885                                 BFD_RELOC_MICROMIPS_7_PCREL_S1);
17886           else
17887             abort ();
17888
17889           fixp->fx_file = fragp->fr_file;
17890           fixp->fx_line = fragp->fr_line;
17891
17892           /* These relocations can have an addend that won't fit in
17893              2 octets.  */
17894           fixp->fx_no_overflow = 1;
17895
17896           return;
17897         }
17898
17899       /* Handle 32-bit branches that fit or are forced to fit.  */
17900       if (!RELAX_MICROMIPS_RELAX32 (fragp->fr_subtype)
17901           || !RELAX_MICROMIPS_TOOFAR32 (fragp->fr_subtype))
17902         {
17903           /* We generate a fixup instead of applying it right now,
17904              because if there is linker relaxation, we're going to
17905              need the relocations.  */
17906           fixp = fix_new_exp (fragp, buf - (bfd_byte *) fragp->fr_literal,
17907                               4, &exp, TRUE, BFD_RELOC_MICROMIPS_16_PCREL_S1);
17908           fixp->fx_file = fragp->fr_file;
17909           fixp->fx_line = fragp->fr_line;
17910
17911           if (type == 0)
17912             return;
17913         }
17914
17915       /* Relax 16-bit branches to 32-bit branches.  */
17916       if (type != 0)
17917         {
17918           if (target_big_endian)
17919             insn = bfd_getb16 (buf);
17920           else
17921             insn = bfd_getl16 (buf);
17922
17923           if ((insn & 0xfc00) == 0xcc00)                /* b16  */
17924             insn = 0x94000000;                          /* beq  */
17925           else if ((insn & 0xdc00) == 0x8c00)           /* beqz16/bnez16  */
17926             {
17927               unsigned long regno;
17928
17929               regno = (insn >> MICROMIPSOP_SH_MD) & MICROMIPSOP_MASK_MD;
17930               regno = micromips_to_32_reg_d_map [regno];
17931               insn = ((insn & 0x2000) << 16) | 0x94000000;      /* beq/bne  */
17932               insn |= regno << MICROMIPSOP_SH_RS;
17933             }
17934           else
17935             abort ();
17936
17937           /* Nothing else to do, just write it out.  */
17938           if (!RELAX_MICROMIPS_RELAX32 (fragp->fr_subtype)
17939               || !RELAX_MICROMIPS_TOOFAR32 (fragp->fr_subtype))
17940             {
17941               md_number_to_chars ((char *) buf, insn >> 16, 2);
17942               buf += 2;
17943               md_number_to_chars ((char *) buf, insn & 0xffff, 2);
17944               buf += 2;
17945
17946               gas_assert (buf == ((bfd_byte *) fragp->fr_literal
17947                                   + fragp->fr_fix));
17948               return;
17949             }
17950         }
17951       else
17952         {
17953           unsigned long next;
17954
17955           if (target_big_endian)
17956             {
17957               insn = bfd_getb16 (buf);
17958               next = bfd_getb16 (buf + 2);
17959             }
17960           else
17961             {
17962               insn = bfd_getl16 (buf);
17963               next = bfd_getl16 (buf + 2);
17964             }
17965           insn = (insn << 16) | next;
17966         }
17967
17968       /* Relax 32-bit branches to a sequence of instructions.  */
17969       as_warn_where (fragp->fr_file, fragp->fr_line,
17970                      _("Relaxed out-of-range branch into a jump"));
17971
17972       /* Set the short-delay-slot bit.  */
17973       short_ds = al && (insn & 0x02000000) != 0;
17974
17975       if (!RELAX_MICROMIPS_UNCOND (fragp->fr_subtype))
17976         {
17977           symbolS *l;
17978
17979           /* Reverse the branch.  */
17980           if ((insn & 0xfc000000) == 0x94000000                 /* beq  */
17981               || (insn & 0xfc000000) == 0xb4000000)             /* bne  */
17982             insn ^= 0x20000000;
17983           else if ((insn & 0xffe00000) == 0x40000000            /* bltz  */
17984                    || (insn & 0xffe00000) == 0x40400000         /* bgez  */
17985                    || (insn & 0xffe00000) == 0x40800000         /* blez  */
17986                    || (insn & 0xffe00000) == 0x40c00000         /* bgtz  */
17987                    || (insn & 0xffe00000) == 0x40a00000         /* bnezc  */
17988                    || (insn & 0xffe00000) == 0x40e00000         /* beqzc  */
17989                    || (insn & 0xffe00000) == 0x40200000         /* bltzal  */
17990                    || (insn & 0xffe00000) == 0x40600000         /* bgezal  */
17991                    || (insn & 0xffe00000) == 0x42200000         /* bltzals  */
17992                    || (insn & 0xffe00000) == 0x42600000)        /* bgezals  */
17993             insn ^= 0x00400000;
17994           else if ((insn & 0xffe30000) == 0x43800000            /* bc1f  */
17995                    || (insn & 0xffe30000) == 0x43a00000         /* bc1t  */
17996                    || (insn & 0xffe30000) == 0x42800000         /* bc2f  */
17997                    || (insn & 0xffe30000) == 0x42a00000)        /* bc2t  */
17998             insn ^= 0x00200000;
17999           else
18000             abort ();
18001
18002           if (al)
18003             {
18004               /* Clear the and-link and short-delay-slot bits.  */
18005               gas_assert ((insn & 0xfda00000) == 0x40200000);
18006
18007               /* bltzal  0x40200000     bgezal  0x40600000  */
18008               /* bltzals 0x42200000     bgezals 0x42600000  */
18009               insn &= ~0x02200000;
18010             }
18011
18012           /* Make a label at the end for use with the branch.  */
18013           l = symbol_new (micromips_label_name (), asec, fragp->fr_fix, fragp);
18014           micromips_label_inc ();
18015 #if defined(OBJ_ELF) || defined(OBJ_MAYBE_ELF)
18016           if (IS_ELF)
18017             S_SET_OTHER (l, ELF_ST_SET_MICROMIPS (S_GET_OTHER (l)));
18018 #endif
18019
18020           /* Refer to it.  */
18021           fixp = fix_new (fragp, buf - (bfd_byte *) fragp->fr_literal,
18022                           4, l, 0, TRUE, BFD_RELOC_MICROMIPS_16_PCREL_S1);
18023           fixp->fx_file = fragp->fr_file;
18024           fixp->fx_line = fragp->fr_line;
18025
18026           /* Branch over the jump.  */
18027           md_number_to_chars ((char *) buf, insn >> 16, 2);
18028           buf += 2;
18029           md_number_to_chars ((char *) buf, insn & 0xffff, 2);
18030           buf += 2;
18031
18032           if (!compact)
18033             {
18034               /* nop  */
18035               insn = 0x0c00;
18036               md_number_to_chars ((char *) buf, insn, 2);
18037               buf += 2;
18038             }
18039         }
18040
18041       if (mips_pic == NO_PIC)
18042         {
18043           unsigned long jal = short_ds ? 0x74000000 : 0xf4000000; /* jal/s  */
18044
18045           /* j/jal/jals <sym>  R_MICROMIPS_26_S1  */
18046           insn = al ? jal : 0xd4000000;
18047
18048           fixp = fix_new_exp (fragp, buf - (bfd_byte *) fragp->fr_literal,
18049                               4, &exp, FALSE, BFD_RELOC_MICROMIPS_JMP);
18050           fixp->fx_file = fragp->fr_file;
18051           fixp->fx_line = fragp->fr_line;
18052
18053           md_number_to_chars ((char *) buf, insn >> 16, 2);
18054           buf += 2;
18055           md_number_to_chars ((char *) buf, insn & 0xffff, 2);
18056           buf += 2;
18057
18058           if (compact)
18059             {
18060               /* nop  */
18061               insn = 0x0c00;
18062               md_number_to_chars ((char *) buf, insn, 2);
18063               buf += 2;
18064             }
18065         }
18066       else
18067         {
18068           unsigned long at = RELAX_MICROMIPS_AT (fragp->fr_subtype);
18069           unsigned long jalr = short_ds ? 0x45e0 : 0x45c0;      /* jalr/s  */
18070           unsigned long jr = compact ? 0x45a0 : 0x4580;         /* jr/c  */
18071
18072           /* lw/ld $at, <sym>($gp)  R_MICROMIPS_GOT16  */
18073           insn = HAVE_64BIT_ADDRESSES ? 0xdc1c0000 : 0xfc1c0000;
18074           insn |= at << MICROMIPSOP_SH_RT;
18075
18076           if (exp.X_add_number)
18077             {
18078               exp.X_add_symbol = make_expr_symbol (&exp);
18079               exp.X_add_number = 0;
18080             }
18081
18082           fixp = fix_new_exp (fragp, buf - (bfd_byte *) fragp->fr_literal,
18083                               4, &exp, FALSE, BFD_RELOC_MICROMIPS_GOT16);
18084           fixp->fx_file = fragp->fr_file;
18085           fixp->fx_line = fragp->fr_line;
18086
18087           md_number_to_chars ((char *) buf, insn >> 16, 2);
18088           buf += 2;
18089           md_number_to_chars ((char *) buf, insn & 0xffff, 2);
18090           buf += 2;
18091
18092           /* d/addiu $at, $at, <sym>  R_MICROMIPS_LO16  */
18093           insn = HAVE_64BIT_ADDRESSES ? 0x5c000000 : 0x30000000;
18094           insn |= at << MICROMIPSOP_SH_RT | at << MICROMIPSOP_SH_RS;
18095
18096           fixp = fix_new_exp (fragp, buf - (bfd_byte *) fragp->fr_literal,
18097                               4, &exp, FALSE, BFD_RELOC_MICROMIPS_LO16);
18098           fixp->fx_file = fragp->fr_file;
18099           fixp->fx_line = fragp->fr_line;
18100
18101           md_number_to_chars ((char *) buf, insn >> 16, 2);
18102           buf += 2;
18103           md_number_to_chars ((char *) buf, insn & 0xffff, 2);
18104           buf += 2;
18105
18106           /* jr/jrc/jalr/jalrs $at  */
18107           insn = al ? jalr : jr;
18108           insn |= at << MICROMIPSOP_SH_MJ;
18109
18110           md_number_to_chars ((char *) buf, insn & 0xffff, 2);
18111           buf += 2;
18112         }
18113
18114       gas_assert (buf == (bfd_byte *) fragp->fr_literal + fragp->fr_fix);
18115       return;
18116     }
18117
18118   if (RELAX_MIPS16_P (fragp->fr_subtype))
18119     {
18120       int type;
18121       const struct mips16_immed_operand *op;
18122       bfd_boolean small, ext;
18123       offsetT val;
18124       bfd_byte *buf;
18125       unsigned long insn;
18126       bfd_boolean use_extend;
18127       unsigned short extend;
18128
18129       type = RELAX_MIPS16_TYPE (fragp->fr_subtype);
18130       op = mips16_immed_operands;
18131       while (op->type != type)
18132         ++op;
18133
18134       if (RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
18135         {
18136           small = FALSE;
18137           ext = TRUE;
18138         }
18139       else
18140         {
18141           small = TRUE;
18142           ext = FALSE;
18143         }
18144
18145       val = resolve_symbol_value (fragp->fr_symbol);
18146       if (op->pcrel)
18147         {
18148           addressT addr;
18149
18150           addr = fragp->fr_address + fragp->fr_fix;
18151
18152           /* The rules for the base address of a PC relative reloc are
18153              complicated; see mips16_extended_frag.  */
18154           if (type == 'p' || type == 'q')
18155             {
18156               addr += 2;
18157               if (ext)
18158                 addr += 2;
18159               /* Ignore the low bit in the target, since it will be
18160                  set for a text label.  */
18161               if ((val & 1) != 0)
18162                 --val;
18163             }
18164           else if (RELAX_MIPS16_JAL_DSLOT (fragp->fr_subtype))
18165             addr -= 4;
18166           else if (RELAX_MIPS16_DSLOT (fragp->fr_subtype))
18167             addr -= 2;
18168
18169           addr &= ~ (addressT) ((1 << op->shift) - 1);
18170           val -= addr;
18171
18172           /* Make sure the section winds up with the alignment we have
18173              assumed.  */
18174           if (op->shift > 0)
18175             record_alignment (asec, op->shift);
18176         }
18177
18178       if (ext
18179           && (RELAX_MIPS16_JAL_DSLOT (fragp->fr_subtype)
18180               || RELAX_MIPS16_DSLOT (fragp->fr_subtype)))
18181         as_warn_where (fragp->fr_file, fragp->fr_line,
18182                        _("extended instruction in delay slot"));
18183
18184       buf = (bfd_byte *) (fragp->fr_literal + fragp->fr_fix);
18185
18186       if (target_big_endian)
18187         insn = bfd_getb16 (buf);
18188       else
18189         insn = bfd_getl16 (buf);
18190
18191       mips16_immed (fragp->fr_file, fragp->fr_line, type, val,
18192                     RELAX_MIPS16_USER_EXT (fragp->fr_subtype),
18193                     small, ext, &insn, &use_extend, &extend);
18194
18195       if (use_extend)
18196         {
18197           md_number_to_chars ((char *) buf, 0xf000 | extend, 2);
18198           fragp->fr_fix += 2;
18199           buf += 2;
18200         }
18201
18202       md_number_to_chars ((char *) buf, insn, 2);
18203       fragp->fr_fix += 2;
18204       buf += 2;
18205     }
18206   else
18207     {
18208       relax_substateT subtype = fragp->fr_subtype;
18209       bfd_boolean second_longer = (subtype & RELAX_SECOND_LONGER) != 0;
18210       bfd_boolean use_second = (subtype & RELAX_USE_SECOND) != 0;
18211       int first, second;
18212       fixS *fixp;
18213
18214       first = RELAX_FIRST (subtype);
18215       second = RELAX_SECOND (subtype);
18216       fixp = (fixS *) fragp->fr_opcode;
18217
18218       /* If the delay slot chosen does not match the size of the instruction,
18219          then emit a warning.  */
18220       if ((!use_second && (subtype & RELAX_DELAY_SLOT_SIZE_FIRST) != 0)
18221            || (use_second && (subtype & RELAX_DELAY_SLOT_SIZE_SECOND) != 0))
18222         {
18223           relax_substateT s;
18224           const char *msg;
18225
18226           s = subtype & (RELAX_DELAY_SLOT_16BIT
18227                          | RELAX_DELAY_SLOT_SIZE_FIRST
18228                          | RELAX_DELAY_SLOT_SIZE_SECOND);
18229           msg = macro_warning (s);
18230           if (msg != NULL)
18231             as_warn_where (fragp->fr_file, fragp->fr_line, "%s", msg);
18232           subtype &= ~s;
18233         }
18234
18235       /* Possibly emit a warning if we've chosen the longer option.  */
18236       if (use_second == second_longer)
18237         {
18238           relax_substateT s;
18239           const char *msg;
18240
18241           s = (subtype
18242                & (RELAX_SECOND_LONGER | RELAX_NOMACRO | RELAX_DELAY_SLOT));
18243           msg = macro_warning (s);
18244           if (msg != NULL)
18245             as_warn_where (fragp->fr_file, fragp->fr_line, "%s", msg);
18246           subtype &= ~s;
18247         }
18248
18249       /* Go through all the fixups for the first sequence.  Disable them
18250          (by marking them as done) if we're going to use the second
18251          sequence instead.  */
18252       while (fixp
18253              && fixp->fx_frag == fragp
18254              && fixp->fx_where < fragp->fr_fix - second)
18255         {
18256           if (subtype & RELAX_USE_SECOND)
18257             fixp->fx_done = 1;
18258           fixp = fixp->fx_next;
18259         }
18260
18261       /* Go through the fixups for the second sequence.  Disable them if
18262          we're going to use the first sequence, otherwise adjust their
18263          addresses to account for the relaxation.  */
18264       while (fixp && fixp->fx_frag == fragp)
18265         {
18266           if (subtype & RELAX_USE_SECOND)
18267             fixp->fx_where -= first;
18268           else
18269             fixp->fx_done = 1;
18270           fixp = fixp->fx_next;
18271         }
18272
18273       /* Now modify the frag contents.  */
18274       if (subtype & RELAX_USE_SECOND)
18275         {
18276           char *start;
18277
18278           start = fragp->fr_literal + fragp->fr_fix - first - second;
18279           memmove (start, start + first, second);
18280           fragp->fr_fix -= first;
18281         }
18282       else
18283         fragp->fr_fix -= second;
18284     }
18285 }
18286
18287 #ifdef OBJ_ELF
18288
18289 /* This function is called after the relocs have been generated.
18290    We've been storing mips16 text labels as odd.  Here we convert them
18291    back to even for the convenience of the debugger.  */
18292
18293 void
18294 mips_frob_file_after_relocs (void)
18295 {
18296   asymbol **syms;
18297   unsigned int count, i;
18298
18299   if (!IS_ELF)
18300     return;
18301
18302   syms = bfd_get_outsymbols (stdoutput);
18303   count = bfd_get_symcount (stdoutput);
18304   for (i = 0; i < count; i++, syms++)
18305     if (ELF_ST_IS_COMPRESSED (elf_symbol (*syms)->internal_elf_sym.st_other)
18306         && ((*syms)->value & 1) != 0)
18307       {
18308         (*syms)->value &= ~1;
18309         /* If the symbol has an odd size, it was probably computed
18310            incorrectly, so adjust that as well.  */
18311         if ((elf_symbol (*syms)->internal_elf_sym.st_size & 1) != 0)
18312           ++elf_symbol (*syms)->internal_elf_sym.st_size;
18313       }
18314 }
18315
18316 #endif
18317
18318 /* This function is called whenever a label is defined, including fake
18319    labels instantiated off the dot special symbol.  It is used when
18320    handling branch delays; if a branch has a label, we assume we cannot
18321    move it.  This also bumps the value of the symbol by 1 in compressed
18322    code.  */
18323
18324 void
18325 mips_record_label (symbolS *sym)
18326 {
18327   segment_info_type *si = seg_info (now_seg);
18328   struct insn_label_list *l;
18329
18330   if (free_insn_labels == NULL)
18331     l = (struct insn_label_list *) xmalloc (sizeof *l);
18332   else
18333     {
18334       l = free_insn_labels;
18335       free_insn_labels = l->next;
18336     }
18337
18338   l->label = sym;
18339   l->next = si->label_list;
18340   si->label_list = l;
18341 }
18342
18343 /* This function is called as tc_frob_label() whenever a label is defined
18344    and adds a DWARF-2 record we only want for true labels.  */
18345
18346 void
18347 mips_define_label (symbolS *sym)
18348 {
18349   mips_record_label (sym);
18350 #ifdef OBJ_ELF
18351   dwarf2_emit_label (sym);
18352 #endif
18353 }
18354 \f
18355 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
18356
18357 /* Some special processing for a MIPS ELF file.  */
18358
18359 void
18360 mips_elf_final_processing (void)
18361 {
18362   /* Write out the register information.  */
18363   if (mips_abi != N64_ABI)
18364     {
18365       Elf32_RegInfo s;
18366
18367       s.ri_gprmask = mips_gprmask;
18368       s.ri_cprmask[0] = mips_cprmask[0];
18369       s.ri_cprmask[1] = mips_cprmask[1];
18370       s.ri_cprmask[2] = mips_cprmask[2];
18371       s.ri_cprmask[3] = mips_cprmask[3];
18372       /* The gp_value field is set by the MIPS ELF backend.  */
18373
18374       bfd_mips_elf32_swap_reginfo_out (stdoutput, &s,
18375                                        ((Elf32_External_RegInfo *)
18376                                         mips_regmask_frag));
18377     }
18378   else
18379     {
18380       Elf64_Internal_RegInfo s;
18381
18382       s.ri_gprmask = mips_gprmask;
18383       s.ri_pad = 0;
18384       s.ri_cprmask[0] = mips_cprmask[0];
18385       s.ri_cprmask[1] = mips_cprmask[1];
18386       s.ri_cprmask[2] = mips_cprmask[2];
18387       s.ri_cprmask[3] = mips_cprmask[3];
18388       /* The gp_value field is set by the MIPS ELF backend.  */
18389
18390       bfd_mips_elf64_swap_reginfo_out (stdoutput, &s,
18391                                        ((Elf64_External_RegInfo *)
18392                                         mips_regmask_frag));
18393     }
18394
18395   /* Set the MIPS ELF flag bits.  FIXME: There should probably be some
18396      sort of BFD interface for this.  */
18397   if (mips_any_noreorder)
18398     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_NOREORDER;
18399   if (mips_pic != NO_PIC)
18400     {
18401       elf_elfheader (stdoutput)->e_flags |= EF_MIPS_PIC;
18402       elf_elfheader (stdoutput)->e_flags |= EF_MIPS_CPIC;
18403     }
18404   if (mips_abicalls)
18405     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_CPIC;
18406
18407   /* Set MIPS ELF flags for ASEs.  */
18408   /* We may need to define a new flag for DSP ASE, and set this flag when
18409      file_ase_dsp is true.  */
18410   /* Same for DSP R2.  */
18411   /* We may need to define a new flag for MT ASE, and set this flag when
18412      file_ase_mt is true.  */
18413   if (file_ase_mips16)
18414     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_ARCH_ASE_M16;
18415   if (file_ase_micromips)
18416     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_ARCH_ASE_MICROMIPS;
18417 #if 0 /* XXX FIXME */
18418   if (file_ase_mips3d)
18419     elf_elfheader (stdoutput)->e_flags |= ???;
18420 #endif
18421   if (file_ase_mdmx)
18422     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_ARCH_ASE_MDMX;
18423
18424   /* Set the MIPS ELF ABI flags.  */
18425   if (mips_abi == O32_ABI && USE_E_MIPS_ABI_O32)
18426     elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_O32;
18427   else if (mips_abi == O64_ABI)
18428     elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_O64;
18429   else if (mips_abi == EABI_ABI)
18430     {
18431       if (!file_mips_gp32)
18432         elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_EABI64;
18433       else
18434         elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_EABI32;
18435     }
18436   else if (mips_abi == N32_ABI)
18437     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_ABI2;
18438
18439   /* Nothing to do for N64_ABI.  */
18440
18441   if (mips_32bitmode)
18442     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_32BITMODE;
18443
18444 #if 0 /* XXX FIXME */
18445   /* 32 bit code with 64 bit FP registers.  */
18446   if (!file_mips_fp32 && ABI_NEEDS_32BIT_REGS (mips_abi))
18447     elf_elfheader (stdoutput)->e_flags |= ???;
18448 #endif
18449 }
18450
18451 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */
18452 \f
18453 typedef struct proc {
18454   symbolS *func_sym;
18455   symbolS *func_end_sym;
18456   unsigned long reg_mask;
18457   unsigned long reg_offset;
18458   unsigned long fpreg_mask;
18459   unsigned long fpreg_offset;
18460   unsigned long frame_offset;
18461   unsigned long frame_reg;
18462   unsigned long pc_reg;
18463 } procS;
18464
18465 static procS cur_proc;
18466 static procS *cur_proc_ptr;
18467 static int numprocs;
18468
18469 /* Implement NOP_OPCODE.  We encode a MIPS16 nop as "1", a microMIPS nop
18470    as "2", and a normal nop as "0".  */
18471
18472 #define NOP_OPCODE_MIPS         0
18473 #define NOP_OPCODE_MIPS16       1
18474 #define NOP_OPCODE_MICROMIPS    2
18475
18476 char
18477 mips_nop_opcode (void)
18478 {
18479   if (seg_info (now_seg)->tc_segment_info_data.micromips)
18480     return NOP_OPCODE_MICROMIPS;
18481   else if (seg_info (now_seg)->tc_segment_info_data.mips16)
18482     return NOP_OPCODE_MIPS16;
18483   else
18484     return NOP_OPCODE_MIPS;
18485 }
18486
18487 /* Fill in an rs_align_code fragment.  Unlike elsewhere we want to use
18488    32-bit microMIPS NOPs here (if applicable).  */
18489
18490 void
18491 mips_handle_align (fragS *fragp)
18492 {
18493   char nop_opcode;
18494   char *p;
18495   int bytes, size, excess;
18496   valueT opcode;
18497
18498   if (fragp->fr_type != rs_align_code)
18499     return;
18500
18501   p = fragp->fr_literal + fragp->fr_fix;
18502   nop_opcode = *p;
18503   switch (nop_opcode)
18504     {
18505     case NOP_OPCODE_MICROMIPS:
18506       opcode = micromips_nop32_insn.insn_opcode;
18507       size = 4;
18508       break;
18509     case NOP_OPCODE_MIPS16:
18510       opcode = mips16_nop_insn.insn_opcode;
18511       size = 2;
18512       break;
18513     case NOP_OPCODE_MIPS:
18514     default:
18515       opcode = nop_insn.insn_opcode;
18516       size = 4;
18517       break;
18518     }
18519
18520   bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
18521   excess = bytes % size;
18522
18523   /* Handle the leading part if we're not inserting a whole number of
18524      instructions, and make it the end of the fixed part of the frag.
18525      Try to fit in a short microMIPS NOP if applicable and possible,
18526      and use zeroes otherwise.  */
18527   gas_assert (excess < 4);
18528   fragp->fr_fix += excess;
18529   switch (excess)
18530     {
18531     case 3:
18532       *p++ = '\0';
18533       /* Fall through.  */
18534     case 2:
18535       if (nop_opcode == NOP_OPCODE_MICROMIPS)
18536         {
18537           md_number_to_chars (p, micromips_nop16_insn.insn_opcode, 2);
18538           p += 2;
18539           break;
18540         }
18541       *p++ = '\0';
18542       /* Fall through.  */
18543     case 1:
18544       *p++ = '\0';
18545       /* Fall through.  */
18546     case 0:
18547       break;
18548     }
18549
18550   md_number_to_chars (p, opcode, size);
18551   fragp->fr_var = size;
18552 }
18553
18554 static void
18555 md_obj_begin (void)
18556 {
18557 }
18558
18559 static void
18560 md_obj_end (void)
18561 {
18562   /* Check for premature end, nesting errors, etc.  */
18563   if (cur_proc_ptr)
18564     as_warn (_("missing .end at end of assembly"));
18565 }
18566
18567 static long
18568 get_number (void)
18569 {
18570   int negative = 0;
18571   long val = 0;
18572
18573   if (*input_line_pointer == '-')
18574     {
18575       ++input_line_pointer;
18576       negative = 1;
18577     }
18578   if (!ISDIGIT (*input_line_pointer))
18579     as_bad (_("expected simple number"));
18580   if (input_line_pointer[0] == '0')
18581     {
18582       if (input_line_pointer[1] == 'x')
18583         {
18584           input_line_pointer += 2;
18585           while (ISXDIGIT (*input_line_pointer))
18586             {
18587               val <<= 4;
18588               val |= hex_value (*input_line_pointer++);
18589             }
18590           return negative ? -val : val;
18591         }
18592       else
18593         {
18594           ++input_line_pointer;
18595           while (ISDIGIT (*input_line_pointer))
18596             {
18597               val <<= 3;
18598               val |= *input_line_pointer++ - '0';
18599             }
18600           return negative ? -val : val;
18601         }
18602     }
18603   if (!ISDIGIT (*input_line_pointer))
18604     {
18605       printf (_(" *input_line_pointer == '%c' 0x%02x\n"),
18606               *input_line_pointer, *input_line_pointer);
18607       as_warn (_("invalid number"));
18608       return -1;
18609     }
18610   while (ISDIGIT (*input_line_pointer))
18611     {
18612       val *= 10;
18613       val += *input_line_pointer++ - '0';
18614     }
18615   return negative ? -val : val;
18616 }
18617
18618 /* The .file directive; just like the usual .file directive, but there
18619    is an initial number which is the ECOFF file index.  In the non-ECOFF
18620    case .file implies DWARF-2.  */
18621
18622 static void
18623 s_mips_file (int x ATTRIBUTE_UNUSED)
18624 {
18625   static int first_file_directive = 0;
18626
18627   if (ECOFF_DEBUGGING)
18628     {
18629       get_number ();
18630       s_app_file (0);
18631     }
18632   else
18633     {
18634       char *filename;
18635
18636       filename = dwarf2_directive_file (0);
18637
18638       /* Versions of GCC up to 3.1 start files with a ".file"
18639          directive even for stabs output.  Make sure that this
18640          ".file" is handled.  Note that you need a version of GCC
18641          after 3.1 in order to support DWARF-2 on MIPS.  */
18642       if (filename != NULL && ! first_file_directive)
18643         {
18644           (void) new_logical_line (filename, -1);
18645           s_app_file_string (filename, 0);
18646         }
18647       first_file_directive = 1;
18648     }
18649 }
18650
18651 /* The .loc directive, implying DWARF-2.  */
18652
18653 static void
18654 s_mips_loc (int x ATTRIBUTE_UNUSED)
18655 {
18656   if (!ECOFF_DEBUGGING)
18657     dwarf2_directive_loc (0);
18658 }
18659
18660 /* The .end directive.  */
18661
18662 static void
18663 s_mips_end (int x ATTRIBUTE_UNUSED)
18664 {
18665   symbolS *p;
18666
18667   /* Following functions need their own .frame and .cprestore directives.  */
18668   mips_frame_reg_valid = 0;
18669   mips_cprestore_valid = 0;
18670
18671   if (!is_end_of_line[(unsigned char) *input_line_pointer])
18672     {
18673       p = get_symbol ();
18674       demand_empty_rest_of_line ();
18675     }
18676   else
18677     p = NULL;
18678
18679   if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) == 0)
18680     as_warn (_(".end not in text section"));
18681
18682   if (!cur_proc_ptr)
18683     {
18684       as_warn (_(".end directive without a preceding .ent directive."));
18685       demand_empty_rest_of_line ();
18686       return;
18687     }
18688
18689   if (p != NULL)
18690     {
18691       gas_assert (S_GET_NAME (p));
18692       if (strcmp (S_GET_NAME (p), S_GET_NAME (cur_proc_ptr->func_sym)))
18693         as_warn (_(".end symbol does not match .ent symbol."));
18694
18695       if (debug_type == DEBUG_STABS)
18696         stabs_generate_asm_endfunc (S_GET_NAME (p),
18697                                     S_GET_NAME (p));
18698     }
18699   else
18700     as_warn (_(".end directive missing or unknown symbol"));
18701
18702 #ifdef OBJ_ELF
18703   /* Create an expression to calculate the size of the function.  */
18704   if (p && cur_proc_ptr)
18705     {
18706       OBJ_SYMFIELD_TYPE *obj = symbol_get_obj (p);
18707       expressionS *exp = xmalloc (sizeof (expressionS));
18708
18709       obj->size = exp;
18710       exp->X_op = O_subtract;
18711       exp->X_add_symbol = symbol_temp_new_now ();
18712       exp->X_op_symbol = p;
18713       exp->X_add_number = 0;
18714
18715       cur_proc_ptr->func_end_sym = exp->X_add_symbol;
18716     }
18717
18718   /* Generate a .pdr section.  */
18719   if (IS_ELF && !ECOFF_DEBUGGING && mips_flag_pdr)
18720     {
18721       segT saved_seg = now_seg;
18722       subsegT saved_subseg = now_subseg;
18723       expressionS exp;
18724       char *fragp;
18725
18726 #ifdef md_flush_pending_output
18727       md_flush_pending_output ();
18728 #endif
18729
18730       gas_assert (pdr_seg);
18731       subseg_set (pdr_seg, 0);
18732
18733       /* Write the symbol.  */
18734       exp.X_op = O_symbol;
18735       exp.X_add_symbol = p;
18736       exp.X_add_number = 0;
18737       emit_expr (&exp, 4);
18738
18739       fragp = frag_more (7 * 4);
18740
18741       md_number_to_chars (fragp, cur_proc_ptr->reg_mask, 4);
18742       md_number_to_chars (fragp + 4, cur_proc_ptr->reg_offset, 4);
18743       md_number_to_chars (fragp + 8, cur_proc_ptr->fpreg_mask, 4);
18744       md_number_to_chars (fragp + 12, cur_proc_ptr->fpreg_offset, 4);
18745       md_number_to_chars (fragp + 16, cur_proc_ptr->frame_offset, 4);
18746       md_number_to_chars (fragp + 20, cur_proc_ptr->frame_reg, 4);
18747       md_number_to_chars (fragp + 24, cur_proc_ptr->pc_reg, 4);
18748
18749       subseg_set (saved_seg, saved_subseg);
18750     }
18751 #endif /* OBJ_ELF */
18752
18753   cur_proc_ptr = NULL;
18754 }
18755
18756 /* The .aent and .ent directives.  */
18757
18758 static void
18759 s_mips_ent (int aent)
18760 {
18761   symbolS *symbolP;
18762
18763   symbolP = get_symbol ();
18764   if (*input_line_pointer == ',')
18765     ++input_line_pointer;
18766   SKIP_WHITESPACE ();
18767   if (ISDIGIT (*input_line_pointer)
18768       || *input_line_pointer == '-')
18769     get_number ();
18770
18771   if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) == 0)
18772     as_warn (_(".ent or .aent not in text section."));
18773
18774   if (!aent && cur_proc_ptr)
18775     as_warn (_("missing .end"));
18776
18777   if (!aent)
18778     {
18779       /* This function needs its own .frame and .cprestore directives.  */
18780       mips_frame_reg_valid = 0;
18781       mips_cprestore_valid = 0;
18782
18783       cur_proc_ptr = &cur_proc;
18784       memset (cur_proc_ptr, '\0', sizeof (procS));
18785
18786       cur_proc_ptr->func_sym = symbolP;
18787
18788       ++numprocs;
18789
18790       if (debug_type == DEBUG_STABS)
18791         stabs_generate_asm_func (S_GET_NAME (symbolP),
18792                                  S_GET_NAME (symbolP));
18793     }
18794
18795   symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
18796
18797   demand_empty_rest_of_line ();
18798 }
18799
18800 /* The .frame directive. If the mdebug section is present (IRIX 5 native)
18801    then ecoff.c (ecoff_directive_frame) is used. For embedded targets,
18802    s_mips_frame is used so that we can set the PDR information correctly.
18803    We can't use the ecoff routines because they make reference to the ecoff
18804    symbol table (in the mdebug section).  */
18805
18806 static void
18807 s_mips_frame (int ignore ATTRIBUTE_UNUSED)
18808 {
18809 #ifdef OBJ_ELF
18810   if (IS_ELF && !ECOFF_DEBUGGING)
18811     {
18812       long val;
18813
18814       if (cur_proc_ptr == (procS *) NULL)
18815         {
18816           as_warn (_(".frame outside of .ent"));
18817           demand_empty_rest_of_line ();
18818           return;
18819         }
18820
18821       cur_proc_ptr->frame_reg = tc_get_register (1);
18822
18823       SKIP_WHITESPACE ();
18824       if (*input_line_pointer++ != ','
18825           || get_absolute_expression_and_terminator (&val) != ',')
18826         {
18827           as_warn (_("Bad .frame directive"));
18828           --input_line_pointer;
18829           demand_empty_rest_of_line ();
18830           return;
18831         }
18832
18833       cur_proc_ptr->frame_offset = val;
18834       cur_proc_ptr->pc_reg = tc_get_register (0);
18835
18836       demand_empty_rest_of_line ();
18837     }
18838   else
18839 #endif /* OBJ_ELF */
18840     s_ignore (ignore);
18841 }
18842
18843 /* The .fmask and .mask directives. If the mdebug section is present
18844    (IRIX 5 native) then ecoff.c (ecoff_directive_mask) is used. For
18845    embedded targets, s_mips_mask is used so that we can set the PDR
18846    information correctly. We can't use the ecoff routines because they
18847    make reference to the ecoff symbol table (in the mdebug section).  */
18848
18849 static void
18850 s_mips_mask (int reg_type)
18851 {
18852 #ifdef OBJ_ELF
18853   if (IS_ELF && !ECOFF_DEBUGGING)
18854     {
18855       long mask, off;
18856
18857       if (cur_proc_ptr == (procS *) NULL)
18858         {
18859           as_warn (_(".mask/.fmask outside of .ent"));
18860           demand_empty_rest_of_line ();
18861           return;
18862         }
18863
18864       if (get_absolute_expression_and_terminator (&mask) != ',')
18865         {
18866           as_warn (_("Bad .mask/.fmask directive"));
18867           --input_line_pointer;
18868           demand_empty_rest_of_line ();
18869           return;
18870         }
18871
18872       off = get_absolute_expression ();
18873
18874       if (reg_type == 'F')
18875         {
18876           cur_proc_ptr->fpreg_mask = mask;
18877           cur_proc_ptr->fpreg_offset = off;
18878         }
18879       else
18880         {
18881           cur_proc_ptr->reg_mask = mask;
18882           cur_proc_ptr->reg_offset = off;
18883         }
18884
18885       demand_empty_rest_of_line ();
18886     }
18887   else
18888 #endif /* OBJ_ELF */
18889     s_ignore (reg_type);
18890 }
18891
18892 /* A table describing all the processors gas knows about.  Names are
18893    matched in the order listed.
18894
18895    To ease comparison, please keep this table in the same order as
18896    gcc's mips_cpu_info_table[].  */
18897 static const struct mips_cpu_info mips_cpu_info_table[] =
18898 {
18899   /* Entries for generic ISAs */
18900   { "mips1",          MIPS_CPU_IS_ISA,          ISA_MIPS1,      CPU_R3000 },
18901   { "mips2",          MIPS_CPU_IS_ISA,          ISA_MIPS2,      CPU_R6000 },
18902   { "mips3",          MIPS_CPU_IS_ISA,          ISA_MIPS3,      CPU_R4000 },
18903   { "mips4",          MIPS_CPU_IS_ISA,          ISA_MIPS4,      CPU_R8000 },
18904   { "mips5",          MIPS_CPU_IS_ISA,          ISA_MIPS5,      CPU_MIPS5 },
18905   { "mips32",         MIPS_CPU_IS_ISA,          ISA_MIPS32,     CPU_MIPS32 },
18906   { "mips32r2",       MIPS_CPU_IS_ISA,          ISA_MIPS32R2,   CPU_MIPS32R2 },
18907   { "mips64",         MIPS_CPU_IS_ISA,          ISA_MIPS64,     CPU_MIPS64 },
18908   { "mips64r2",       MIPS_CPU_IS_ISA,          ISA_MIPS64R2,   CPU_MIPS64R2 },
18909
18910   /* MIPS I */
18911   { "r3000",          0,                        ISA_MIPS1,      CPU_R3000 },
18912   { "r2000",          0,                        ISA_MIPS1,      CPU_R3000 },
18913   { "r3900",          0,                        ISA_MIPS1,      CPU_R3900 },
18914
18915   /* MIPS II */
18916   { "r6000",          0,                        ISA_MIPS2,      CPU_R6000 },
18917
18918   /* MIPS III */
18919   { "r4000",          0,                        ISA_MIPS3,      CPU_R4000 },
18920   { "r4010",          0,                        ISA_MIPS2,      CPU_R4010 },
18921   { "vr4100",         0,                        ISA_MIPS3,      CPU_VR4100 },
18922   { "vr4111",         0,                        ISA_MIPS3,      CPU_R4111 },
18923   { "vr4120",         0,                        ISA_MIPS3,      CPU_VR4120 },
18924   { "vr4130",         0,                        ISA_MIPS3,      CPU_VR4120 },
18925   { "vr4181",         0,                        ISA_MIPS3,      CPU_R4111 },
18926   { "vr4300",         0,                        ISA_MIPS3,      CPU_R4300 },
18927   { "r4400",          0,                        ISA_MIPS3,      CPU_R4400 },
18928   { "r4600",          0,                        ISA_MIPS3,      CPU_R4600 },
18929   { "orion",          0,                        ISA_MIPS3,      CPU_R4600 },
18930   { "r4650",          0,                        ISA_MIPS3,      CPU_R4650 },
18931   /* ST Microelectronics Loongson 2E and 2F cores */
18932   { "loongson2e",     0,                        ISA_MIPS3,   CPU_LOONGSON_2E },
18933   { "loongson2f",     0,                        ISA_MIPS3,   CPU_LOONGSON_2F },
18934
18935   /* MIPS IV */
18936   { "r8000",          0,                        ISA_MIPS4,      CPU_R8000 },
18937   { "r10000",         0,                        ISA_MIPS4,      CPU_R10000 },
18938   { "r12000",         0,                        ISA_MIPS4,      CPU_R12000 },
18939   { "r14000",         0,                        ISA_MIPS4,      CPU_R14000 },
18940   { "r16000",         0,                        ISA_MIPS4,      CPU_R16000 },
18941   { "vr5000",         0,                        ISA_MIPS4,      CPU_R5000 },
18942   { "vr5400",         0,                        ISA_MIPS4,      CPU_VR5400 },
18943   { "vr5500",         0,                        ISA_MIPS4,      CPU_VR5500 },
18944   { "rm5200",         0,                        ISA_MIPS4,      CPU_R5000 },
18945   { "rm5230",         0,                        ISA_MIPS4,      CPU_R5000 },
18946   { "rm5231",         0,                        ISA_MIPS4,      CPU_R5000 },
18947   { "rm5261",         0,                        ISA_MIPS4,      CPU_R5000 },
18948   { "rm5721",         0,                        ISA_MIPS4,      CPU_R5000 },
18949   { "rm7000",         0,                        ISA_MIPS4,      CPU_RM7000 },
18950   { "rm9000",         0,                        ISA_MIPS4,      CPU_RM9000 },
18951
18952   /* MIPS 32 */
18953   { "4kc",            0,                        ISA_MIPS32,     CPU_MIPS32 },
18954   { "4km",            0,                        ISA_MIPS32,     CPU_MIPS32 },
18955   { "4kp",            0,                        ISA_MIPS32,     CPU_MIPS32 },
18956   { "4ksc",           MIPS_CPU_ASE_SMARTMIPS,   ISA_MIPS32,     CPU_MIPS32 },
18957
18958   /* MIPS 32 Release 2 */
18959   { "4kec",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18960   { "4kem",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18961   { "4kep",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18962   { "4ksd",           MIPS_CPU_ASE_SMARTMIPS,   ISA_MIPS32R2,   CPU_MIPS32R2 },
18963   { "m4k",            0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18964   { "m4kp",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18965   { "m14k",           MIPS_CPU_ASE_MCU,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18966   { "m14kc",          MIPS_CPU_ASE_MCU,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18967   { "m14ke",          MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2 | MIPS_CPU_ASE_MCU,
18968                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
18969   { "m14kec",         MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2 | MIPS_CPU_ASE_MCU,
18970                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
18971   { "24kc",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18972   { "24kf2_1",        0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18973   { "24kf",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18974   { "24kf1_1",        0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18975   /* Deprecated forms of the above.  */
18976   { "24kfx",          0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18977   { "24kx",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
18978   /* 24KE is a 24K with DSP ASE, other ASEs are optional.  */
18979   { "24kec",          MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18980   { "24kef2_1",       MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18981   { "24kef",          MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18982   { "24kef1_1",       MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18983   /* Deprecated forms of the above.  */
18984   { "24kefx",         MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18985   { "24kex",          MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
18986   /* 34K is a 24K with DSP and MT ASE, other ASEs are optional.  */
18987   { "34kc",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
18988                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
18989   { "34kf2_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
18990                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
18991   { "34kf",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
18992                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
18993   { "34kf1_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
18994                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
18995   /* Deprecated forms of the above.  */
18996   { "34kfx",          MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
18997                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
18998   { "34kx",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
18999                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19000   /* 74K with DSP and DSPR2 ASE, other ASEs are optional.  */
19001   { "74kc",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
19002                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19003   { "74kf2_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
19004                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19005   { "74kf",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
19006                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19007   { "74kf1_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
19008                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19009   { "74kf3_2",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
19010                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19011   /* Deprecated forms of the above.  */
19012   { "74kfx",          MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
19013                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19014   { "74kx",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
19015                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19016   /* 1004K cores are multiprocessor versions of the 34K.  */
19017   { "1004kc",         MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
19018                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19019   { "1004kf2_1",      MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
19020                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19021   { "1004kf",         MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
19022                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19023   { "1004kf1_1",      MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
19024                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
19025
19026   /* MIPS 64 */
19027   { "5kc",            0,                        ISA_MIPS64,     CPU_MIPS64 },
19028   { "5kf",            0,                        ISA_MIPS64,     CPU_MIPS64 },
19029   { "20kc",           MIPS_CPU_ASE_MIPS3D,      ISA_MIPS64,     CPU_MIPS64 },
19030   { "25kf",           MIPS_CPU_ASE_MIPS3D,      ISA_MIPS64,     CPU_MIPS64 },
19031
19032   /* Broadcom SB-1 CPU core */
19033   { "sb1",            MIPS_CPU_ASE_MIPS3D | MIPS_CPU_ASE_MDMX,
19034                                                 ISA_MIPS64,     CPU_SB1 },
19035   /* Broadcom SB-1A CPU core */
19036   { "sb1a",           MIPS_CPU_ASE_MIPS3D | MIPS_CPU_ASE_MDMX,
19037                                                 ISA_MIPS64,     CPU_SB1 },
19038   
19039   { "loongson3a",     0,                        ISA_MIPS64,     CPU_LOONGSON_3A },
19040
19041   /* MIPS 64 Release 2 */
19042
19043   /* Cavium Networks Octeon CPU core */
19044   { "octeon",         0,      ISA_MIPS64R2,   CPU_OCTEON },
19045
19046   /* RMI Xlr */
19047   { "xlr",            0,      ISA_MIPS64,     CPU_XLR },
19048
19049   /* End marker */
19050   { NULL, 0, 0, 0 }
19051 };
19052
19053
19054 /* Return true if GIVEN is the same as CANONICAL, or if it is CANONICAL
19055    with a final "000" replaced by "k".  Ignore case.
19056
19057    Note: this function is shared between GCC and GAS.  */
19058
19059 static bfd_boolean
19060 mips_strict_matching_cpu_name_p (const char *canonical, const char *given)
19061 {
19062   while (*given != 0 && TOLOWER (*given) == TOLOWER (*canonical))
19063     given++, canonical++;
19064
19065   return ((*given == 0 && *canonical == 0)
19066           || (strcmp (canonical, "000") == 0 && strcasecmp (given, "k") == 0));
19067 }
19068
19069
19070 /* Return true if GIVEN matches CANONICAL, where GIVEN is a user-supplied
19071    CPU name.  We've traditionally allowed a lot of variation here.
19072
19073    Note: this function is shared between GCC and GAS.  */
19074
19075 static bfd_boolean
19076 mips_matching_cpu_name_p (const char *canonical, const char *given)
19077 {
19078   /* First see if the name matches exactly, or with a final "000"
19079      turned into "k".  */
19080   if (mips_strict_matching_cpu_name_p (canonical, given))
19081     return TRUE;
19082
19083   /* If not, try comparing based on numerical designation alone.
19084      See if GIVEN is an unadorned number, or 'r' followed by a number.  */
19085   if (TOLOWER (*given) == 'r')
19086     given++;
19087   if (!ISDIGIT (*given))
19088     return FALSE;
19089
19090   /* Skip over some well-known prefixes in the canonical name,
19091      hoping to find a number there too.  */
19092   if (TOLOWER (canonical[0]) == 'v' && TOLOWER (canonical[1]) == 'r')
19093     canonical += 2;
19094   else if (TOLOWER (canonical[0]) == 'r' && TOLOWER (canonical[1]) == 'm')
19095     canonical += 2;
19096   else if (TOLOWER (canonical[0]) == 'r')
19097     canonical += 1;
19098
19099   return mips_strict_matching_cpu_name_p (canonical, given);
19100 }
19101
19102
19103 /* Parse an option that takes the name of a processor as its argument.
19104    OPTION is the name of the option and CPU_STRING is the argument.
19105    Return the corresponding processor enumeration if the CPU_STRING is
19106    recognized, otherwise report an error and return null.
19107
19108    A similar function exists in GCC.  */
19109
19110 static const struct mips_cpu_info *
19111 mips_parse_cpu (const char *option, const char *cpu_string)
19112 {
19113   const struct mips_cpu_info *p;
19114
19115   /* 'from-abi' selects the most compatible architecture for the given
19116      ABI: MIPS I for 32-bit ABIs and MIPS III for 64-bit ABIs.  For the
19117      EABIs, we have to decide whether we're using the 32-bit or 64-bit
19118      version.  Look first at the -mgp options, if given, otherwise base
19119      the choice on MIPS_DEFAULT_64BIT.
19120
19121      Treat NO_ABI like the EABIs.  One reason to do this is that the
19122      plain 'mips' and 'mips64' configs have 'from-abi' as their default
19123      architecture.  This code picks MIPS I for 'mips' and MIPS III for
19124      'mips64', just as we did in the days before 'from-abi'.  */
19125   if (strcasecmp (cpu_string, "from-abi") == 0)
19126     {
19127       if (ABI_NEEDS_32BIT_REGS (mips_abi))
19128         return mips_cpu_info_from_isa (ISA_MIPS1);
19129
19130       if (ABI_NEEDS_64BIT_REGS (mips_abi))
19131         return mips_cpu_info_from_isa (ISA_MIPS3);
19132
19133       if (file_mips_gp32 >= 0)
19134         return mips_cpu_info_from_isa (file_mips_gp32 ? ISA_MIPS1 : ISA_MIPS3);
19135
19136       return mips_cpu_info_from_isa (MIPS_DEFAULT_64BIT
19137                                      ? ISA_MIPS3
19138                                      : ISA_MIPS1);
19139     }
19140
19141   /* 'default' has traditionally been a no-op.  Probably not very useful.  */
19142   if (strcasecmp (cpu_string, "default") == 0)
19143     return 0;
19144
19145   for (p = mips_cpu_info_table; p->name != 0; p++)
19146     if (mips_matching_cpu_name_p (p->name, cpu_string))
19147       return p;
19148
19149   as_bad (_("Bad value (%s) for %s"), cpu_string, option);
19150   return 0;
19151 }
19152
19153 /* Return the canonical processor information for ISA (a member of the
19154    ISA_MIPS* enumeration).  */
19155
19156 static const struct mips_cpu_info *
19157 mips_cpu_info_from_isa (int isa)
19158 {
19159   int i;
19160
19161   for (i = 0; mips_cpu_info_table[i].name != NULL; i++)
19162     if ((mips_cpu_info_table[i].flags & MIPS_CPU_IS_ISA)
19163         && isa == mips_cpu_info_table[i].isa)
19164       return (&mips_cpu_info_table[i]);
19165
19166   return NULL;
19167 }
19168
19169 static const struct mips_cpu_info *
19170 mips_cpu_info_from_arch (int arch)
19171 {
19172   int i;
19173
19174   for (i = 0; mips_cpu_info_table[i].name != NULL; i++)
19175     if (arch == mips_cpu_info_table[i].cpu)
19176       return (&mips_cpu_info_table[i]);
19177
19178   return NULL;
19179 }
19180 \f
19181 static void
19182 show (FILE *stream, const char *string, int *col_p, int *first_p)
19183 {
19184   if (*first_p)
19185     {
19186       fprintf (stream, "%24s", "");
19187       *col_p = 24;
19188     }
19189   else
19190     {
19191       fprintf (stream, ", ");
19192       *col_p += 2;
19193     }
19194
19195   if (*col_p + strlen (string) > 72)
19196     {
19197       fprintf (stream, "\n%24s", "");
19198       *col_p = 24;
19199     }
19200
19201   fprintf (stream, "%s", string);
19202   *col_p += strlen (string);
19203
19204   *first_p = 0;
19205 }
19206
19207 void
19208 md_show_usage (FILE *stream)
19209 {
19210   int column, first;
19211   size_t i;
19212
19213   fprintf (stream, _("\
19214 MIPS options:\n\
19215 -EB                     generate big endian output\n\
19216 -EL                     generate little endian output\n\
19217 -g, -g2                 do not remove unneeded NOPs or swap branches\n\
19218 -G NUM                  allow referencing objects up to NUM bytes\n\
19219                         implicitly with the gp register [default 8]\n"));
19220   fprintf (stream, _("\
19221 -mips1                  generate MIPS ISA I instructions\n\
19222 -mips2                  generate MIPS ISA II instructions\n\
19223 -mips3                  generate MIPS ISA III instructions\n\
19224 -mips4                  generate MIPS ISA IV instructions\n\
19225 -mips5                  generate MIPS ISA V instructions\n\
19226 -mips32                 generate MIPS32 ISA instructions\n\
19227 -mips32r2               generate MIPS32 release 2 ISA instructions\n\
19228 -mips64                 generate MIPS64 ISA instructions\n\
19229 -mips64r2               generate MIPS64 release 2 ISA instructions\n\
19230 -march=CPU/-mtune=CPU   generate code/schedule for CPU, where CPU is one of:\n"));
19231
19232   first = 1;
19233
19234   for (i = 0; mips_cpu_info_table[i].name != NULL; i++)
19235     show (stream, mips_cpu_info_table[i].name, &column, &first);
19236   show (stream, "from-abi", &column, &first);
19237   fputc ('\n', stream);
19238
19239   fprintf (stream, _("\
19240 -mCPU                   equivalent to -march=CPU -mtune=CPU. Deprecated.\n\
19241 -no-mCPU                don't generate code specific to CPU.\n\
19242                         For -mCPU and -no-mCPU, CPU must be one of:\n"));
19243
19244   first = 1;
19245
19246   show (stream, "3900", &column, &first);
19247   show (stream, "4010", &column, &first);
19248   show (stream, "4100", &column, &first);
19249   show (stream, "4650", &column, &first);
19250   fputc ('\n', stream);
19251
19252   fprintf (stream, _("\
19253 -mips16                 generate mips16 instructions\n\
19254 -no-mips16              do not generate mips16 instructions\n"));
19255   fprintf (stream, _("\
19256 -mmicromips             generate microMIPS instructions\n\
19257 -mno-micromips          do not generate microMIPS instructions\n"));
19258   fprintf (stream, _("\
19259 -msmartmips             generate smartmips instructions\n\
19260 -mno-smartmips          do not generate smartmips instructions\n"));  
19261   fprintf (stream, _("\
19262 -mdsp                   generate DSP instructions\n\
19263 -mno-dsp                do not generate DSP instructions\n"));
19264   fprintf (stream, _("\
19265 -mdspr2                 generate DSP R2 instructions\n\
19266 -mno-dspr2              do not generate DSP R2 instructions\n"));
19267   fprintf (stream, _("\
19268 -mmt                    generate MT instructions\n\
19269 -mno-mt                 do not generate MT instructions\n"));
19270   fprintf (stream, _("\
19271 -mmcu                   generate MCU instructions\n\
19272 -mno-mcu                do not generate MCU instructions\n"));
19273   fprintf (stream, _("\
19274 -mfix-loongson2f-jump   work around Loongson2F JUMP instructions\n\
19275 -mfix-loongson2f-nop    work around Loongson2F NOP errata\n\
19276 -mfix-vr4120            work around certain VR4120 errata\n\
19277 -mfix-vr4130            work around VR4130 mflo/mfhi errata\n\
19278 -mfix-24k               insert a nop after ERET and DERET instructions\n\
19279 -mfix-cn63xxp1          work around CN63XXP1 PREF errata\n\
19280 -mgp32                  use 32-bit GPRs, regardless of the chosen ISA\n\
19281 -mfp32                  use 32-bit FPRs, regardless of the chosen ISA\n\
19282 -msym32                 assume all symbols have 32-bit values\n\
19283 -O0                     remove unneeded NOPs, do not swap branches\n\
19284 -O                      remove unneeded NOPs and swap branches\n\
19285 --trap, --no-break      trap exception on div by 0 and mult overflow\n\
19286 --break, --no-trap      break exception on div by 0 and mult overflow\n"));
19287   fprintf (stream, _("\
19288 -mhard-float            allow floating-point instructions\n\
19289 -msoft-float            do not allow floating-point instructions\n\
19290 -msingle-float          only allow 32-bit floating-point operations\n\
19291 -mdouble-float          allow 32-bit and 64-bit floating-point operations\n\
19292 --[no-]construct-floats [dis]allow floating point values to be constructed\n"
19293                      ));
19294 #ifdef OBJ_ELF
19295   fprintf (stream, _("\
19296 -KPIC, -call_shared     generate SVR4 position independent code\n\
19297 -call_nonpic            generate non-PIC code that can operate with DSOs\n\
19298 -mvxworks-pic           generate VxWorks position independent code\n\
19299 -non_shared             do not generate code that can operate with DSOs\n\
19300 -xgot                   assume a 32 bit GOT\n\
19301 -mpdr, -mno-pdr         enable/disable creation of .pdr sections\n\
19302 -mshared, -mno-shared   disable/enable .cpload optimization for\n\
19303                         position dependent (non shared) code\n\
19304 -mabi=ABI               create ABI conformant object file for:\n"));
19305
19306   first = 1;
19307
19308   show (stream, "32", &column, &first);
19309   show (stream, "o64", &column, &first);
19310   show (stream, "n32", &column, &first);
19311   show (stream, "64", &column, &first);
19312   show (stream, "eabi", &column, &first);
19313
19314   fputc ('\n', stream);
19315
19316   fprintf (stream, _("\
19317 -32                     create o32 ABI object file (default)\n\
19318 -n32                    create n32 ABI object file\n\
19319 -64                     create 64 ABI object file\n"));
19320 #endif
19321 }
19322
19323 #ifdef TE_IRIX
19324 enum dwarf2_format
19325 mips_dwarf2_format (asection *sec ATTRIBUTE_UNUSED)
19326 {
19327   if (HAVE_64BIT_SYMBOLS)
19328     return dwarf2_format_64bit_irix;
19329   else
19330     return dwarf2_format_32bit;
19331 }
19332 #endif
19333
19334 int
19335 mips_dwarf2_addr_size (void)
19336 {
19337   if (HAVE_64BIT_OBJECTS)
19338     return 8;
19339   else
19340     return 4;
19341 }
19342
19343 /* Standard calling conventions leave the CFA at SP on entry.  */
19344 void
19345 mips_cfi_frame_initial_instructions (void)
19346 {
19347   cfi_add_CFA_def_cfa_register (SP);
19348 }
19349
19350 int
19351 tc_mips_regname_to_dw2regnum (char *regname)
19352 {
19353   unsigned int regnum = -1;
19354   unsigned int reg;
19355
19356   if (reg_lookup (&regname, RTYPE_GP | RTYPE_NUM, &reg))
19357     regnum = reg;
19358
19359   return regnum;
19360 }