* config/tc-mips.c (md_convert_frag): Remove a call to
[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
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 TREG 24
95 #define PIC_CALL_REG 25
96 #define KT0 26
97 #define KT1 27
98 #define GP  28
99 #define SP  29
100 #define FP  30
101 #define RA  31
102
103 #define ILLEGAL_REG (32)
104
105 #define AT  mips_opts.at
106
107 /* Allow override of standard little-endian ECOFF format.  */
108
109 #ifndef ECOFF_LITTLE_FORMAT
110 #define ECOFF_LITTLE_FORMAT "ecoff-littlemips"
111 #endif
112
113 extern int target_big_endian;
114
115 /* The name of the readonly data section.  */
116 #define RDATA_SECTION_NAME (OUTPUT_FLAVOR == bfd_target_ecoff_flavour \
117                             ? ".rdata" \
118                             : OUTPUT_FLAVOR == bfd_target_coff_flavour \
119                             ? ".rdata" \
120                             : OUTPUT_FLAVOR == bfd_target_elf_flavour \
121                             ? ".rodata" \
122                             : (abort (), ""))
123
124 /* Information about an instruction, including its format, operands
125    and fixups.  */
126 struct mips_cl_insn
127 {
128   /* The opcode's entry in mips_opcodes or mips16_opcodes.  */
129   const struct mips_opcode *insn_mo;
130
131   /* True if this is a mips16 instruction and if we want the extended
132      form of INSN_MO.  */
133   bfd_boolean use_extend;
134
135   /* The 16-bit extension instruction to use when USE_EXTEND is true.  */
136   unsigned short extend;
137
138   /* The 16-bit or 32-bit bitstring of the instruction itself.  This is
139      a copy of INSN_MO->match with the operands filled in.  */
140   unsigned long insn_opcode;
141
142   /* The frag that contains the instruction.  */
143   struct frag *frag;
144
145   /* The offset into FRAG of the first instruction byte.  */
146   long where;
147
148   /* The relocs associated with the instruction, if any.  */
149   fixS *fixp[3];
150
151   /* True if this entry cannot be moved from its current position.  */
152   unsigned int fixed_p : 1;
153
154   /* True if this instruction occurred in a .set noreorder block.  */
155   unsigned int noreorder_p : 1;
156
157   /* True for mips16 instructions that jump to an absolute address.  */
158   unsigned int mips16_absolute_jump_p : 1;
159 };
160
161 /* The ABI to use.  */
162 enum mips_abi_level
163 {
164   NO_ABI = 0,
165   O32_ABI,
166   O64_ABI,
167   N32_ABI,
168   N64_ABI,
169   EABI_ABI
170 };
171
172 /* MIPS ABI we are using for this output file.  */
173 static enum mips_abi_level mips_abi = NO_ABI;
174
175 /* Whether or not we have code that can call pic code.  */
176 int mips_abicalls = FALSE;
177
178 /* Whether or not we have code which can be put into a shared
179    library.  */
180 static bfd_boolean mips_in_shared = TRUE;
181
182 /* This is the set of options which may be modified by the .set
183    pseudo-op.  We use a struct so that .set push and .set pop are more
184    reliable.  */
185
186 struct mips_set_options
187 {
188   /* MIPS ISA (Instruction Set Architecture) level.  This is set to -1
189      if it has not been initialized.  Changed by `.set mipsN', and the
190      -mipsN command line option, and the default CPU.  */
191   int isa;
192   /* Enabled Application Specific Extensions (ASEs).  These are set to -1
193      if they have not been initialized.  Changed by `.set <asename>', by
194      command line options, and based on the default architecture.  */
195   int ase_mips3d;
196   int ase_mdmx;
197   int ase_smartmips;
198   int ase_dsp;
199   int ase_dspr2;
200   int ase_mt;
201   /* Whether we are assembling for the mips16 processor.  0 if we are
202      not, 1 if we are, and -1 if the value has not been initialized.
203      Changed by `.set mips16' and `.set nomips16', and the -mips16 and
204      -nomips16 command line options, and the default CPU.  */
205   int mips16;
206   /* Non-zero if we should not reorder instructions.  Changed by `.set
207      reorder' and `.set noreorder'.  */
208   int noreorder;
209   /* Non-zero if we should not permit the register designated "assembler
210      temporary" to be used in instructions.  The value is the register
211      number, normally $at ($1).  Changed by `.set at=REG', `.set noat'
212      (same as `.set at=$0') and `.set at' (same as `.set at=$1').  */
213   unsigned int at;
214   /* Non-zero if we should warn when a macro instruction expands into
215      more than one machine instruction.  Changed by `.set nomacro' and
216      `.set macro'.  */
217   int warn_about_macros;
218   /* Non-zero if we should not move instructions.  Changed by `.set
219      move', `.set volatile', `.set nomove', and `.set novolatile'.  */
220   int nomove;
221   /* Non-zero if we should not optimize branches by moving the target
222      of the branch into the delay slot.  Actually, we don't perform
223      this optimization anyhow.  Changed by `.set bopt' and `.set
224      nobopt'.  */
225   int nobopt;
226   /* Non-zero if we should not autoextend mips16 instructions.
227      Changed by `.set autoextend' and `.set noautoextend'.  */
228   int noautoextend;
229   /* Restrict general purpose registers and floating point registers
230      to 32 bit.  This is initially determined when -mgp32 or -mfp32
231      is passed but can changed if the assembler code uses .set mipsN.  */
232   int gp32;
233   int fp32;
234   /* MIPS architecture (CPU) type.  Changed by .set arch=FOO, the -march
235      command line option, and the default CPU.  */
236   int arch;
237   /* True if ".set sym32" is in effect.  */
238   bfd_boolean sym32;
239   /* True if floating-point operations are not allowed.  Changed by .set
240      softfloat or .set hardfloat, by command line options -msoft-float or
241      -mhard-float.  The default is false.  */
242   bfd_boolean soft_float;
243
244   /* True if only single-precision floating-point operations are allowed.
245      Changed by .set singlefloat or .set doublefloat, command-line options
246      -msingle-float or -mdouble-float.  The default is false.  */
247   bfd_boolean single_float;
248 };
249
250 /* This is the struct we use to hold the current set of options.  Note
251    that we must set the isa field to ISA_UNKNOWN and the ASE fields to
252    -1 to indicate that they have not been initialized.  */
253
254 /* True if -mgp32 was passed.  */
255 static int file_mips_gp32 = -1;
256
257 /* True if -mfp32 was passed.  */
258 static int file_mips_fp32 = -1;
259
260 /* 1 if -msoft-float, 0 if -mhard-float.  The default is 0.  */
261 static int file_mips_soft_float = 0;
262
263 /* 1 if -msingle-float, 0 if -mdouble-float.  The default is 0.   */
264 static int file_mips_single_float = 0;
265
266 static struct mips_set_options mips_opts =
267 {
268   /* isa */ ISA_UNKNOWN, /* ase_mips3d */ -1, /* ase_mdmx */ -1,
269   /* ase_smartmips */ 0, /* ase_dsp */ -1, /* ase_dspr2 */ -1, /* ase_mt */ -1,
270   /* mips16 */ -1, /* noreorder */ 0, /* at */ ATREG,
271   /* warn_about_macros */ 0, /* nomove */ 0, /* nobopt */ 0,
272   /* noautoextend */ 0, /* gp32 */ 0, /* fp32 */ 0, /* arch */ CPU_UNKNOWN,
273   /* sym32 */ FALSE, /* soft_float */ FALSE, /* single_float */ FALSE
274 };
275
276 /* These variables are filled in with the masks of registers used.
277    The object format code reads them and puts them in the appropriate
278    place.  */
279 unsigned long mips_gprmask;
280 unsigned long mips_cprmask[4];
281
282 /* MIPS ISA we are using for this output file.  */
283 static int file_mips_isa = ISA_UNKNOWN;
284
285 /* True if -mips16 was passed or implied by arguments passed on the
286    command line (e.g., by -march).  */
287 static int file_ase_mips16;
288
289 #define ISA_SUPPORTS_MIPS16E (mips_opts.isa == ISA_MIPS32               \
290                               || mips_opts.isa == ISA_MIPS32R2          \
291                               || mips_opts.isa == ISA_MIPS64            \
292                               || mips_opts.isa == ISA_MIPS64R2)
293
294 /* True if we want to create R_MIPS_JALR for jalr $25.  */
295 #ifdef TE_IRIX
296 #define MIPS_JALR_HINT_P(EXPR) HAVE_NEWABI
297 #else
298 /* As a GNU extension, we use R_MIPS_JALR for o32 too.  However,
299    because there's no place for any addend, the only acceptable
300    expression is a bare symbol.  */
301 #define MIPS_JALR_HINT_P(EXPR) \
302   (!HAVE_IN_PLACE_ADDENDS \
303    || ((EXPR)->X_op == O_symbol && (EXPR)->X_add_number == 0))
304 #endif
305
306 /* True if -mips3d was passed or implied by arguments passed on the
307    command line (e.g., by -march).  */
308 static int file_ase_mips3d;
309
310 /* True if -mdmx was passed or implied by arguments passed on the
311    command line (e.g., by -march).  */
312 static int file_ase_mdmx;
313
314 /* True if -msmartmips was passed or implied by arguments passed on the
315    command line (e.g., by -march).  */
316 static int file_ase_smartmips;
317
318 #define ISA_SUPPORTS_SMARTMIPS (mips_opts.isa == ISA_MIPS32             \
319                                 || mips_opts.isa == ISA_MIPS32R2)
320
321 /* True if -mdsp was passed or implied by arguments passed on the
322    command line (e.g., by -march).  */
323 static int file_ase_dsp;
324
325 #define ISA_SUPPORTS_DSP_ASE (mips_opts.isa == ISA_MIPS32R2             \
326                               || mips_opts.isa == ISA_MIPS64R2)
327
328 #define ISA_SUPPORTS_DSP64_ASE (mips_opts.isa == ISA_MIPS64R2)
329
330 /* True if -mdspr2 was passed or implied by arguments passed on the
331    command line (e.g., by -march).  */
332 static int file_ase_dspr2;
333
334 #define ISA_SUPPORTS_DSPR2_ASE (mips_opts.isa == ISA_MIPS32R2           \
335                                 || mips_opts.isa == ISA_MIPS64R2)
336
337 /* True if -mmt was passed or implied by arguments passed on the
338    command line (e.g., by -march).  */
339 static int file_ase_mt;
340
341 #define ISA_SUPPORTS_MT_ASE (mips_opts.isa == ISA_MIPS32R2              \
342                              || mips_opts.isa == ISA_MIPS64R2)
343
344 /* The argument of the -march= flag.  The architecture we are assembling.  */
345 static int file_mips_arch = CPU_UNKNOWN;
346 static const char *mips_arch_string;
347
348 /* The argument of the -mtune= flag.  The architecture for which we
349    are optimizing.  */
350 static int mips_tune = CPU_UNKNOWN;
351 static const char *mips_tune_string;
352
353 /* True when generating 32-bit code for a 64-bit processor.  */
354 static int mips_32bitmode = 0;
355
356 /* True if the given ABI requires 32-bit registers.  */
357 #define ABI_NEEDS_32BIT_REGS(ABI) ((ABI) == O32_ABI)
358
359 /* Likewise 64-bit registers.  */
360 #define ABI_NEEDS_64BIT_REGS(ABI)       \
361   ((ABI) == N32_ABI                     \
362    || (ABI) == N64_ABI                  \
363    || (ABI) == O64_ABI)
364
365 /*  Return true if ISA supports 64 bit wide gp registers.  */
366 #define ISA_HAS_64BIT_REGS(ISA)         \
367   ((ISA) == ISA_MIPS3                   \
368    || (ISA) == ISA_MIPS4                \
369    || (ISA) == ISA_MIPS5                \
370    || (ISA) == ISA_MIPS64               \
371    || (ISA) == ISA_MIPS64R2)
372
373 /*  Return true if ISA supports 64 bit wide float registers.  */
374 #define ISA_HAS_64BIT_FPRS(ISA)         \
375   ((ISA) == ISA_MIPS3                   \
376    || (ISA) == ISA_MIPS4                \
377    || (ISA) == ISA_MIPS5                \
378    || (ISA) == ISA_MIPS32R2             \
379    || (ISA) == ISA_MIPS64               \
380    || (ISA) == ISA_MIPS64R2)
381
382 /* Return true if ISA supports 64-bit right rotate (dror et al.)
383    instructions.  */
384 #define ISA_HAS_DROR(ISA)               \
385   ((ISA) == ISA_MIPS64R2)
386
387 /* Return true if ISA supports 32-bit right rotate (ror et al.)
388    instructions.  */
389 #define ISA_HAS_ROR(ISA)                \
390   ((ISA) == ISA_MIPS32R2                \
391    || (ISA) == ISA_MIPS64R2             \
392    || mips_opts.ase_smartmips)
393
394 /* Return true if ISA supports single-precision floats in odd registers.  */
395 #define ISA_HAS_ODD_SINGLE_FPR(ISA)     \
396   ((ISA) == ISA_MIPS32                  \
397    || (ISA) == ISA_MIPS32R2             \
398    || (ISA) == ISA_MIPS64               \
399    || (ISA) == ISA_MIPS64R2)
400
401 /* Return true if ISA supports move to/from high part of a 64-bit
402    floating-point register. */
403 #define ISA_HAS_MXHC1(ISA)              \
404   ((ISA) == ISA_MIPS32R2                \
405    || (ISA) == ISA_MIPS64R2)
406
407 #define HAVE_32BIT_GPRS                            \
408     (mips_opts.gp32 || !ISA_HAS_64BIT_REGS (mips_opts.isa))
409
410 #define HAVE_32BIT_FPRS                            \
411     (mips_opts.fp32 || !ISA_HAS_64BIT_FPRS (mips_opts.isa))
412
413 #define HAVE_64BIT_GPRS (!HAVE_32BIT_GPRS)
414 #define HAVE_64BIT_FPRS (!HAVE_32BIT_FPRS)
415
416 #define HAVE_NEWABI (mips_abi == N32_ABI || mips_abi == N64_ABI)
417
418 #define HAVE_64BIT_OBJECTS (mips_abi == N64_ABI)
419
420 /* True if relocations are stored in-place.  */
421 #define HAVE_IN_PLACE_ADDENDS (!HAVE_NEWABI)
422
423 /* The ABI-derived address size.  */
424 #define HAVE_64BIT_ADDRESSES \
425   (HAVE_64BIT_GPRS && (mips_abi == EABI_ABI || mips_abi == N64_ABI))
426 #define HAVE_32BIT_ADDRESSES (!HAVE_64BIT_ADDRESSES)
427
428 /* The size of symbolic constants (i.e., expressions of the form
429    "SYMBOL" or "SYMBOL + OFFSET").  */
430 #define HAVE_32BIT_SYMBOLS \
431   (HAVE_32BIT_ADDRESSES || !HAVE_64BIT_OBJECTS || mips_opts.sym32)
432 #define HAVE_64BIT_SYMBOLS (!HAVE_32BIT_SYMBOLS)
433
434 /* Addresses are loaded in different ways, depending on the address size
435    in use.  The n32 ABI Documentation also mandates the use of additions
436    with overflow checking, but existing implementations don't follow it.  */
437 #define ADDRESS_ADD_INSN                                                \
438    (HAVE_32BIT_ADDRESSES ? "addu" : "daddu")
439
440 #define ADDRESS_ADDI_INSN                                               \
441    (HAVE_32BIT_ADDRESSES ? "addiu" : "daddiu")
442
443 #define ADDRESS_LOAD_INSN                                               \
444    (HAVE_32BIT_ADDRESSES ? "lw" : "ld")
445
446 #define ADDRESS_STORE_INSN                                              \
447    (HAVE_32BIT_ADDRESSES ? "sw" : "sd")
448
449 /* Return true if the given CPU supports the MIPS16 ASE.  */
450 #define CPU_HAS_MIPS16(cpu)                                             \
451    (strncmp (TARGET_CPU, "mips16", sizeof ("mips16") - 1) == 0          \
452     || strncmp (TARGET_CANONICAL, "mips-lsi-elf", sizeof ("mips-lsi-elf") - 1) == 0)
453
454 /* True if CPU has a dror instruction.  */
455 #define CPU_HAS_DROR(CPU)       ((CPU) == CPU_VR5400 || (CPU) == CPU_VR5500)
456
457 /* True if CPU has a ror instruction.  */
458 #define CPU_HAS_ROR(CPU)        CPU_HAS_DROR (CPU)
459
460 /* True if CPU has seq/sne and seqi/snei instructions.  */
461 #define CPU_HAS_SEQ(CPU)        ((CPU) == CPU_OCTEON)
462
463 /* True if CPU does not implement the all the coprocessor insns.  For these
464    CPUs only those COP insns are accepted that are explicitly marked to be
465    available on the CPU.  ISA membership for COP insns is ignored.  */
466 #define NO_ISA_COP(CPU)         ((CPU) == CPU_OCTEON)
467
468 /* True if mflo and mfhi can be immediately followed by instructions
469    which write to the HI and LO registers.
470
471    According to MIPS specifications, MIPS ISAs I, II, and III need
472    (at least) two instructions between the reads of HI/LO and
473    instructions which write them, and later ISAs do not.  Contradicting
474    the MIPS specifications, some MIPS IV processor user manuals (e.g.
475    the UM for the NEC Vr5000) document needing the instructions between
476    HI/LO reads and writes, as well.  Therefore, we declare only MIPS32,
477    MIPS64 and later ISAs to have the interlocks, plus any specific
478    earlier-ISA CPUs for which CPU documentation declares that the
479    instructions are really interlocked.  */
480 #define hilo_interlocks \
481   (mips_opts.isa == ISA_MIPS32                        \
482    || mips_opts.isa == ISA_MIPS32R2                   \
483    || mips_opts.isa == ISA_MIPS64                     \
484    || mips_opts.isa == ISA_MIPS64R2                   \
485    || mips_opts.arch == CPU_R4010                     \
486    || mips_opts.arch == CPU_R10000                    \
487    || mips_opts.arch == CPU_R12000                    \
488    || mips_opts.arch == CPU_R14000                    \
489    || mips_opts.arch == CPU_R16000                    \
490    || mips_opts.arch == CPU_RM7000                    \
491    || mips_opts.arch == CPU_VR5500                    \
492    )
493
494 /* Whether the processor uses hardware interlocks to protect reads
495    from the GPRs after they are loaded from memory, and thus does not
496    require nops to be inserted.  This applies to instructions marked
497    INSN_LOAD_MEMORY_DELAY.  These nops are only required at MIPS ISA
498    level I.  */
499 #define gpr_interlocks \
500   (mips_opts.isa != ISA_MIPS1  \
501    || mips_opts.arch == CPU_R3900)
502
503 /* Whether the processor uses hardware interlocks to avoid delays
504    required by coprocessor instructions, and thus does not require
505    nops to be inserted.  This applies to instructions marked
506    INSN_LOAD_COPROC_DELAY, INSN_COPROC_MOVE_DELAY, and to delays
507    between instructions marked INSN_WRITE_COND_CODE and ones marked
508    INSN_READ_COND_CODE.  These nops are only required at MIPS ISA
509    levels I, II, and III.  */
510 /* Itbl support may require additional care here.  */
511 #define cop_interlocks                                \
512   ((mips_opts.isa != ISA_MIPS1                        \
513     && mips_opts.isa != ISA_MIPS2                     \
514     && mips_opts.isa != ISA_MIPS3)                    \
515    || mips_opts.arch == CPU_R4300                     \
516    )
517
518 /* Whether the processor uses hardware interlocks to protect reads
519    from coprocessor registers after they are loaded from memory, and
520    thus does not require nops to be inserted.  This applies to
521    instructions marked INSN_COPROC_MEMORY_DELAY.  These nops are only
522    requires at MIPS ISA level I.  */
523 #define cop_mem_interlocks (mips_opts.isa != ISA_MIPS1)
524
525 /* Is this a mfhi or mflo instruction?  */
526 #define MF_HILO_INSN(PINFO) \
527   ((PINFO & INSN_READ_HI) || (PINFO & INSN_READ_LO))
528
529 /* Returns true for a (non floating-point) coprocessor instruction.  Reading
530    or writing the condition code is only possible on the coprocessors and
531    these insns are not marked with INSN_COP.  Thus for these insns use the
532    condition-code flags.  */
533 #define COP_INSN(PINFO)                                                 \
534   (PINFO != INSN_MACRO                                                  \
535    && ((PINFO) & (FP_S | FP_D)) == 0                                    \
536    && ((PINFO) & (INSN_COP | INSN_READ_COND_CODE | INSN_WRITE_COND_CODE)))
537
538 /* MIPS PIC level.  */
539
540 enum mips_pic_level mips_pic;
541
542 /* 1 if we should generate 32 bit offsets from the $gp register in
543    SVR4_PIC mode.  Currently has no meaning in other modes.  */
544 static int mips_big_got = 0;
545
546 /* 1 if trap instructions should used for overflow rather than break
547    instructions.  */
548 static int mips_trap = 0;
549
550 /* 1 if double width floating point constants should not be constructed
551    by assembling two single width halves into two single width floating
552    point registers which just happen to alias the double width destination
553    register.  On some architectures this aliasing can be disabled by a bit
554    in the status register, and the setting of this bit cannot be determined
555    automatically at assemble time.  */
556 static int mips_disable_float_construction;
557
558 /* Non-zero if any .set noreorder directives were used.  */
559
560 static int mips_any_noreorder;
561
562 /* Non-zero if nops should be inserted when the register referenced in
563    an mfhi/mflo instruction is read in the next two instructions.  */
564 static int mips_7000_hilo_fix;
565
566 /* The size of objects in the small data section.  */
567 static unsigned int g_switch_value = 8;
568 /* Whether the -G option was used.  */
569 static int g_switch_seen = 0;
570
571 #define N_RMASK 0xc4
572 #define N_VFP   0xd4
573
574 /* If we can determine in advance that GP optimization won't be
575    possible, we can skip the relaxation stuff that tries to produce
576    GP-relative references.  This makes delay slot optimization work
577    better.
578
579    This function can only provide a guess, but it seems to work for
580    gcc output.  It needs to guess right for gcc, otherwise gcc
581    will put what it thinks is a GP-relative instruction in a branch
582    delay slot.
583
584    I don't know if a fix is needed for the SVR4_PIC mode.  I've only
585    fixed it for the non-PIC mode.  KR 95/04/07  */
586 static int nopic_need_relax (symbolS *, int);
587
588 /* handle of the OPCODE hash table */
589 static struct hash_control *op_hash = NULL;
590
591 /* The opcode hash table we use for the mips16.  */
592 static struct hash_control *mips16_op_hash = NULL;
593
594 /* This array holds the chars that always start a comment.  If the
595     pre-processor is disabled, these aren't very useful */
596 const char comment_chars[] = "#";
597
598 /* This array holds the chars that only start a comment at the beginning of
599    a line.  If the line seems to have the form '# 123 filename'
600    .line and .file directives will appear in the pre-processed output */
601 /* Note that input_file.c hand checks for '#' at the beginning of the
602    first line of the input file.  This is because the compiler outputs
603    #NO_APP at the beginning of its output.  */
604 /* Also note that C style comments are always supported.  */
605 const char line_comment_chars[] = "#";
606
607 /* This array holds machine specific line separator characters.  */
608 const char line_separator_chars[] = ";";
609
610 /* Chars that can be used to separate mant from exp in floating point nums */
611 const char EXP_CHARS[] = "eE";
612
613 /* Chars that mean this number is a floating point constant */
614 /* As in 0f12.456 */
615 /* or    0d1.2345e12 */
616 const char FLT_CHARS[] = "rRsSfFdDxXpP";
617
618 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
619    changed in read.c .  Ideally it shouldn't have to know about it at all,
620    but nothing is ideal around here.
621  */
622
623 static char *insn_error;
624
625 static int auto_align = 1;
626
627 /* When outputting SVR4 PIC code, the assembler needs to know the
628    offset in the stack frame from which to restore the $gp register.
629    This is set by the .cprestore pseudo-op, and saved in this
630    variable.  */
631 static offsetT mips_cprestore_offset = -1;
632
633 /* Similar for NewABI PIC code, where $gp is callee-saved.  NewABI has some
634    more optimizations, it can use a register value instead of a memory-saved
635    offset and even an other register than $gp as global pointer.  */
636 static offsetT mips_cpreturn_offset = -1;
637 static int mips_cpreturn_register = -1;
638 static int mips_gp_register = GP;
639 static int mips_gprel_offset = 0;
640
641 /* Whether mips_cprestore_offset has been set in the current function
642    (or whether it has already been warned about, if not).  */
643 static int mips_cprestore_valid = 0;
644
645 /* This is the register which holds the stack frame, as set by the
646    .frame pseudo-op.  This is needed to implement .cprestore.  */
647 static int mips_frame_reg = SP;
648
649 /* Whether mips_frame_reg has been set in the current function
650    (or whether it has already been warned about, if not).  */
651 static int mips_frame_reg_valid = 0;
652
653 /* To output NOP instructions correctly, we need to keep information
654    about the previous two instructions.  */
655
656 /* Whether we are optimizing.  The default value of 2 means to remove
657    unneeded NOPs and swap branch instructions when possible.  A value
658    of 1 means to not swap branches.  A value of 0 means to always
659    insert NOPs.  */
660 static int mips_optimize = 2;
661
662 /* Debugging level.  -g sets this to 2.  -gN sets this to N.  -g0 is
663    equivalent to seeing no -g option at all.  */
664 static int mips_debug = 0;
665
666 /* The maximum number of NOPs needed to avoid the VR4130 mflo/mfhi errata.  */
667 #define MAX_VR4130_NOPS 4
668
669 /* The maximum number of NOPs needed to fill delay slots.  */
670 #define MAX_DELAY_NOPS 2
671
672 /* The maximum number of NOPs needed for any purpose.  */
673 #define MAX_NOPS 4
674
675 /* A list of previous instructions, with index 0 being the most recent.
676    We need to look back MAX_NOPS instructions when filling delay slots
677    or working around processor errata.  We need to look back one
678    instruction further if we're thinking about using history[0] to
679    fill a branch delay slot.  */
680 static struct mips_cl_insn history[1 + MAX_NOPS];
681
682 /* Nop instructions used by emit_nop.  */
683 static struct mips_cl_insn nop_insn, mips16_nop_insn;
684
685 /* The appropriate nop for the current mode.  */
686 #define NOP_INSN (mips_opts.mips16 ? &mips16_nop_insn : &nop_insn)
687
688 /* If this is set, it points to a frag holding nop instructions which
689    were inserted before the start of a noreorder section.  If those
690    nops turn out to be unnecessary, the size of the frag can be
691    decreased.  */
692 static fragS *prev_nop_frag;
693
694 /* The number of nop instructions we created in prev_nop_frag.  */
695 static int prev_nop_frag_holds;
696
697 /* The number of nop instructions that we know we need in
698    prev_nop_frag.  */
699 static int prev_nop_frag_required;
700
701 /* The number of instructions we've seen since prev_nop_frag.  */
702 static int prev_nop_frag_since;
703
704 /* For ECOFF and ELF, relocations against symbols are done in two
705    parts, with a HI relocation and a LO relocation.  Each relocation
706    has only 16 bits of space to store an addend.  This means that in
707    order for the linker to handle carries correctly, it must be able
708    to locate both the HI and the LO relocation.  This means that the
709    relocations must appear in order in the relocation table.
710
711    In order to implement this, we keep track of each unmatched HI
712    relocation.  We then sort them so that they immediately precede the
713    corresponding LO relocation.  */
714
715 struct mips_hi_fixup
716 {
717   /* Next HI fixup.  */
718   struct mips_hi_fixup *next;
719   /* This fixup.  */
720   fixS *fixp;
721   /* The section this fixup is in.  */
722   segT seg;
723 };
724
725 /* The list of unmatched HI relocs.  */
726
727 static struct mips_hi_fixup *mips_hi_fixup_list;
728
729 /* The frag containing the last explicit relocation operator.
730    Null if explicit relocations have not been used.  */
731
732 static fragS *prev_reloc_op_frag;
733
734 /* Map normal MIPS register numbers to mips16 register numbers.  */
735
736 #define X ILLEGAL_REG
737 static const int mips32_to_16_reg_map[] =
738 {
739   X, X, 2, 3, 4, 5, 6, 7,
740   X, X, X, X, X, X, X, X,
741   0, 1, X, X, X, X, X, X,
742   X, X, X, X, X, X, X, X
743 };
744 #undef X
745
746 /* Map mips16 register numbers to normal MIPS register numbers.  */
747
748 static const unsigned int mips16_to_32_reg_map[] =
749 {
750   16, 17, 2, 3, 4, 5, 6, 7
751 };
752
753 /* Classifies the kind of instructions we're interested in when
754    implementing -mfix-vr4120.  */
755 enum fix_vr4120_class
756 {
757   FIX_VR4120_MACC,
758   FIX_VR4120_DMACC,
759   FIX_VR4120_MULT,
760   FIX_VR4120_DMULT,
761   FIX_VR4120_DIV,
762   FIX_VR4120_MTHILO,
763   NUM_FIX_VR4120_CLASSES
764 };
765
766 /* ...likewise -mfix-loongson2f-jump.  */
767 static bfd_boolean mips_fix_loongson2f_jump;
768
769 /* ...likewise -mfix-loongson2f-nop.  */
770 static bfd_boolean mips_fix_loongson2f_nop;
771
772 /* True if -mfix-loongson2f-nop or -mfix-loongson2f-jump passed.  */
773 static bfd_boolean mips_fix_loongson2f;
774
775 /* Given two FIX_VR4120_* values X and Y, bit Y of element X is set if
776    there must be at least one other instruction between an instruction
777    of type X and an instruction of type Y.  */
778 static unsigned int vr4120_conflicts[NUM_FIX_VR4120_CLASSES];
779
780 /* True if -mfix-vr4120 is in force.  */
781 static int mips_fix_vr4120;
782
783 /* ...likewise -mfix-vr4130.  */
784 static int mips_fix_vr4130;
785
786 /* ...likewise -mfix-24k.  */
787 static int mips_fix_24k;
788
789 /* ...likewise -mfix-cn63xxp1 */
790 static bfd_boolean mips_fix_cn63xxp1;
791
792 /* We don't relax branches by default, since this causes us to expand
793    `la .l2 - .l1' if there's a branch between .l1 and .l2, because we
794    fail to compute the offset before expanding the macro to the most
795    efficient expansion.  */
796
797 static int mips_relax_branch;
798 \f
799 /* The expansion of many macros depends on the type of symbol that
800    they refer to.  For example, when generating position-dependent code,
801    a macro that refers to a symbol may have two different expansions,
802    one which uses GP-relative addresses and one which uses absolute
803    addresses.  When generating SVR4-style PIC, a macro may have
804    different expansions for local and global symbols.
805
806    We handle these situations by generating both sequences and putting
807    them in variant frags.  In position-dependent code, the first sequence
808    will be the GP-relative one and the second sequence will be the
809    absolute one.  In SVR4 PIC, the first sequence will be for global
810    symbols and the second will be for local symbols.
811
812    The frag's "subtype" is RELAX_ENCODE (FIRST, SECOND), where FIRST and
813    SECOND are the lengths of the two sequences in bytes.  These fields
814    can be extracted using RELAX_FIRST() and RELAX_SECOND().  In addition,
815    the subtype has the following flags:
816
817    RELAX_USE_SECOND
818         Set if it has been decided that we should use the second
819         sequence instead of the first.
820
821    RELAX_SECOND_LONGER
822         Set in the first variant frag if the macro's second implementation
823         is longer than its first.  This refers to the macro as a whole,
824         not an individual relaxation.
825
826    RELAX_NOMACRO
827         Set in the first variant frag if the macro appeared in a .set nomacro
828         block and if one alternative requires a warning but the other does not.
829
830    RELAX_DELAY_SLOT
831         Like RELAX_NOMACRO, but indicates that the macro appears in a branch
832         delay slot.
833
834    The frag's "opcode" points to the first fixup for relaxable code.
835
836    Relaxable macros are generated using a sequence such as:
837
838       relax_start (SYMBOL);
839       ... generate first expansion ...
840       relax_switch ();
841       ... generate second expansion ...
842       relax_end ();
843
844    The code and fixups for the unwanted alternative are discarded
845    by md_convert_frag.  */
846 #define RELAX_ENCODE(FIRST, SECOND) (((FIRST) << 8) | (SECOND))
847
848 #define RELAX_FIRST(X) (((X) >> 8) & 0xff)
849 #define RELAX_SECOND(X) ((X) & 0xff)
850 #define RELAX_USE_SECOND 0x10000
851 #define RELAX_SECOND_LONGER 0x20000
852 #define RELAX_NOMACRO 0x40000
853 #define RELAX_DELAY_SLOT 0x80000
854
855 /* Branch without likely bit.  If label is out of range, we turn:
856
857         beq reg1, reg2, label
858         delay slot
859
860    into
861
862         bne reg1, reg2, 0f
863         nop
864         j label
865      0: delay slot
866
867    with the following opcode replacements:
868
869         beq <-> bne
870         blez <-> bgtz
871         bltz <-> bgez
872         bc1f <-> bc1t
873
874         bltzal <-> bgezal  (with jal label instead of j label)
875
876    Even though keeping the delay slot instruction in the delay slot of
877    the branch would be more efficient, it would be very tricky to do
878    correctly, because we'd have to introduce a variable frag *after*
879    the delay slot instruction, and expand that instead.  Let's do it
880    the easy way for now, even if the branch-not-taken case now costs
881    one additional instruction.  Out-of-range branches are not supposed
882    to be common, anyway.
883
884    Branch likely.  If label is out of range, we turn:
885
886         beql reg1, reg2, label
887         delay slot (annulled if branch not taken)
888
889    into
890
891         beql reg1, reg2, 1f
892         nop
893         beql $0, $0, 2f
894         nop
895      1: j[al] label
896         delay slot (executed only if branch taken)
897      2:
898
899    It would be possible to generate a shorter sequence by losing the
900    likely bit, generating something like:
901
902         bne reg1, reg2, 0f
903         nop
904         j[al] label
905         delay slot (executed only if branch taken)
906      0:
907
908         beql -> bne
909         bnel -> beq
910         blezl -> bgtz
911         bgtzl -> blez
912         bltzl -> bgez
913         bgezl -> bltz
914         bc1fl -> bc1t
915         bc1tl -> bc1f
916
917         bltzall -> bgezal  (with jal label instead of j label)
918         bgezall -> bltzal  (ditto)
919
920
921    but it's not clear that it would actually improve performance.  */
922 #define RELAX_BRANCH_ENCODE(uncond, likely, link, toofar) \
923   ((relax_substateT) \
924    (0xc0000000 \
925     | ((toofar) ? 1 : 0) \
926     | ((link) ? 2 : 0) \
927     | ((likely) ? 4 : 0) \
928     | ((uncond) ? 8 : 0)))
929 #define RELAX_BRANCH_P(i) (((i) & 0xf0000000) == 0xc0000000)
930 #define RELAX_BRANCH_UNCOND(i) (((i) & 8) != 0)
931 #define RELAX_BRANCH_LIKELY(i) (((i) & 4) != 0)
932 #define RELAX_BRANCH_LINK(i) (((i) & 2) != 0)
933 #define RELAX_BRANCH_TOOFAR(i) (((i) & 1) != 0)
934
935 /* For mips16 code, we use an entirely different form of relaxation.
936    mips16 supports two versions of most instructions which take
937    immediate values: a small one which takes some small value, and a
938    larger one which takes a 16 bit value.  Since branches also follow
939    this pattern, relaxing these values is required.
940
941    We can assemble both mips16 and normal MIPS code in a single
942    object.  Therefore, we need to support this type of relaxation at
943    the same time that we support the relaxation described above.  We
944    use the high bit of the subtype field to distinguish these cases.
945
946    The information we store for this type of relaxation is the
947    argument code found in the opcode file for this relocation, whether
948    the user explicitly requested a small or extended form, and whether
949    the relocation is in a jump or jal delay slot.  That tells us the
950    size of the value, and how it should be stored.  We also store
951    whether the fragment is considered to be extended or not.  We also
952    store whether this is known to be a branch to a different section,
953    whether we have tried to relax this frag yet, and whether we have
954    ever extended a PC relative fragment because of a shift count.  */
955 #define RELAX_MIPS16_ENCODE(type, small, ext, dslot, jal_dslot) \
956   (0x80000000                                                   \
957    | ((type) & 0xff)                                            \
958    | ((small) ? 0x100 : 0)                                      \
959    | ((ext) ? 0x200 : 0)                                        \
960    | ((dslot) ? 0x400 : 0)                                      \
961    | ((jal_dslot) ? 0x800 : 0))
962 #define RELAX_MIPS16_P(i) (((i) & 0xc0000000) == 0x80000000)
963 #define RELAX_MIPS16_TYPE(i) ((i) & 0xff)
964 #define RELAX_MIPS16_USER_SMALL(i) (((i) & 0x100) != 0)
965 #define RELAX_MIPS16_USER_EXT(i) (((i) & 0x200) != 0)
966 #define RELAX_MIPS16_DSLOT(i) (((i) & 0x400) != 0)
967 #define RELAX_MIPS16_JAL_DSLOT(i) (((i) & 0x800) != 0)
968 #define RELAX_MIPS16_EXTENDED(i) (((i) & 0x1000) != 0)
969 #define RELAX_MIPS16_MARK_EXTENDED(i) ((i) | 0x1000)
970 #define RELAX_MIPS16_CLEAR_EXTENDED(i) ((i) &~ 0x1000)
971 #define RELAX_MIPS16_LONG_BRANCH(i) (((i) & 0x2000) != 0)
972 #define RELAX_MIPS16_MARK_LONG_BRANCH(i) ((i) | 0x2000)
973 #define RELAX_MIPS16_CLEAR_LONG_BRANCH(i) ((i) &~ 0x2000)
974
975 /* Is the given value a sign-extended 32-bit value?  */
976 #define IS_SEXT_32BIT_NUM(x)                                            \
977   (((x) &~ (offsetT) 0x7fffffff) == 0                                   \
978    || (((x) &~ (offsetT) 0x7fffffff) == ~ (offsetT) 0x7fffffff))
979
980 /* Is the given value a sign-extended 16-bit value?  */
981 #define IS_SEXT_16BIT_NUM(x)                                            \
982   (((x) &~ (offsetT) 0x7fff) == 0                                       \
983    || (((x) &~ (offsetT) 0x7fff) == ~ (offsetT) 0x7fff))
984
985 /* Is the given value a zero-extended 32-bit value?  Or a negated one?  */
986 #define IS_ZEXT_32BIT_NUM(x)                                            \
987   (((x) &~ (offsetT) 0xffffffff) == 0                                   \
988    || (((x) &~ (offsetT) 0xffffffff) == ~ (offsetT) 0xffffffff))
989
990 /* Replace bits MASK << SHIFT of STRUCT with the equivalent bits in
991    VALUE << SHIFT.  VALUE is evaluated exactly once.  */
992 #define INSERT_BITS(STRUCT, VALUE, MASK, SHIFT) \
993   (STRUCT) = (((STRUCT) & ~((MASK) << (SHIFT))) \
994               | (((VALUE) & (MASK)) << (SHIFT)))
995
996 /* Extract bits MASK << SHIFT from STRUCT and shift them right
997    SHIFT places.  */
998 #define EXTRACT_BITS(STRUCT, MASK, SHIFT) \
999   (((STRUCT) >> (SHIFT)) & (MASK))
1000
1001 /* Change INSN's opcode so that the operand given by FIELD has value VALUE.
1002    INSN is a mips_cl_insn structure and VALUE is evaluated exactly once.
1003
1004    include/opcode/mips.h specifies operand fields using the macros
1005    OP_MASK_<FIELD> and OP_SH_<FIELD>.  The MIPS16 equivalents start
1006    with "MIPS16OP" instead of "OP".  */
1007 #define INSERT_OPERAND(FIELD, INSN, VALUE) \
1008   INSERT_BITS ((INSN).insn_opcode, VALUE, OP_MASK_##FIELD, OP_SH_##FIELD)
1009 #define MIPS16_INSERT_OPERAND(FIELD, INSN, VALUE) \
1010   INSERT_BITS ((INSN).insn_opcode, VALUE, \
1011                 MIPS16OP_MASK_##FIELD, MIPS16OP_SH_##FIELD)
1012
1013 /* Extract the operand given by FIELD from mips_cl_insn INSN.  */
1014 #define EXTRACT_OPERAND(FIELD, INSN) \
1015   EXTRACT_BITS ((INSN).insn_opcode, OP_MASK_##FIELD, OP_SH_##FIELD)
1016 #define MIPS16_EXTRACT_OPERAND(FIELD, INSN) \
1017   EXTRACT_BITS ((INSN).insn_opcode, \
1018                 MIPS16OP_MASK_##FIELD, \
1019                 MIPS16OP_SH_##FIELD)
1020 \f
1021 /* Global variables used when generating relaxable macros.  See the
1022    comment above RELAX_ENCODE for more details about how relaxation
1023    is used.  */
1024 static struct {
1025   /* 0 if we're not emitting a relaxable macro.
1026      1 if we're emitting the first of the two relaxation alternatives.
1027      2 if we're emitting the second alternative.  */
1028   int sequence;
1029
1030   /* The first relaxable fixup in the current frag.  (In other words,
1031      the first fixup that refers to relaxable code.)  */
1032   fixS *first_fixup;
1033
1034   /* sizes[0] says how many bytes of the first alternative are stored in
1035      the current frag.  Likewise sizes[1] for the second alternative.  */
1036   unsigned int sizes[2];
1037
1038   /* The symbol on which the choice of sequence depends.  */
1039   symbolS *symbol;
1040 } mips_relax;
1041 \f
1042 /* Global variables used to decide whether a macro needs a warning.  */
1043 static struct {
1044   /* True if the macro is in a branch delay slot.  */
1045   bfd_boolean delay_slot_p;
1046
1047   /* For relaxable macros, sizes[0] is the length of the first alternative
1048      in bytes and sizes[1] is the length of the second alternative.
1049      For non-relaxable macros, both elements give the length of the
1050      macro in bytes.  */
1051   unsigned int sizes[2];
1052
1053   /* The first variant frag for this macro.  */
1054   fragS *first_frag;
1055 } mips_macro_warning;
1056 \f
1057 /* Prototypes for static functions.  */
1058
1059 #define internalError()                                                 \
1060     as_fatal (_("internal Error, line %d, %s"), __LINE__, __FILE__)
1061
1062 enum mips_regclass { MIPS_GR_REG, MIPS_FP_REG, MIPS16_REG };
1063
1064 static void append_insn
1065   (struct mips_cl_insn *, expressionS *, bfd_reloc_code_real_type *);
1066 static void mips_no_prev_insn (void);
1067 static void macro_build (expressionS *, const char *, const char *, ...);
1068 static void mips16_macro_build
1069   (expressionS *, const char *, const char *, va_list *);
1070 static void load_register (int, expressionS *, int);
1071 static void macro_start (void);
1072 static void macro_end (void);
1073 static void macro (struct mips_cl_insn * ip);
1074 static void mips16_macro (struct mips_cl_insn * ip);
1075 static void mips_ip (char *str, struct mips_cl_insn * ip);
1076 static void mips16_ip (char *str, struct mips_cl_insn * ip);
1077 static void mips16_immed
1078   (char *, unsigned int, int, offsetT, bfd_boolean, bfd_boolean, bfd_boolean,
1079    unsigned long *, bfd_boolean *, unsigned short *);
1080 static size_t my_getSmallExpression
1081   (expressionS *, bfd_reloc_code_real_type *, char *);
1082 static void my_getExpression (expressionS *, char *);
1083 static void s_align (int);
1084 static void s_change_sec (int);
1085 static void s_change_section (int);
1086 static void s_cons (int);
1087 static void s_float_cons (int);
1088 static void s_mips_globl (int);
1089 static void s_option (int);
1090 static void s_mipsset (int);
1091 static void s_abicalls (int);
1092 static void s_cpload (int);
1093 static void s_cpsetup (int);
1094 static void s_cplocal (int);
1095 static void s_cprestore (int);
1096 static void s_cpreturn (int);
1097 static void s_dtprelword (int);
1098 static void s_dtpreldword (int);
1099 static void s_gpvalue (int);
1100 static void s_gpword (int);
1101 static void s_gpdword (int);
1102 static void s_cpadd (int);
1103 static void s_insn (int);
1104 static void md_obj_begin (void);
1105 static void md_obj_end (void);
1106 static void s_mips_ent (int);
1107 static void s_mips_end (int);
1108 static void s_mips_frame (int);
1109 static void s_mips_mask (int reg_type);
1110 static void s_mips_stab (int);
1111 static void s_mips_weakext (int);
1112 static void s_mips_file (int);
1113 static void s_mips_loc (int);
1114 static bfd_boolean pic_need_relax (symbolS *, asection *);
1115 static int relaxed_branch_length (fragS *, asection *, int);
1116 static int validate_mips_insn (const struct mips_opcode *);
1117
1118 /* Table and functions used to map between CPU/ISA names, and
1119    ISA levels, and CPU numbers.  */
1120
1121 struct mips_cpu_info
1122 {
1123   const char *name;           /* CPU or ISA name.  */
1124   int flags;                  /* ASEs available, or ISA flag.  */
1125   int isa;                    /* ISA level.  */
1126   int cpu;                    /* CPU number (default CPU if ISA).  */
1127 };
1128
1129 #define MIPS_CPU_IS_ISA         0x0001  /* Is this an ISA?  (If 0, a CPU.) */
1130 #define MIPS_CPU_ASE_SMARTMIPS  0x0002  /* CPU implements SmartMIPS ASE */
1131 #define MIPS_CPU_ASE_DSP        0x0004  /* CPU implements DSP ASE */
1132 #define MIPS_CPU_ASE_MT         0x0008  /* CPU implements MT ASE */
1133 #define MIPS_CPU_ASE_MIPS3D     0x0010  /* CPU implements MIPS-3D ASE */
1134 #define MIPS_CPU_ASE_MDMX       0x0020  /* CPU implements MDMX ASE */
1135 #define MIPS_CPU_ASE_DSPR2      0x0040  /* CPU implements DSP R2 ASE */
1136
1137 static const struct mips_cpu_info *mips_parse_cpu (const char *, const char *);
1138 static const struct mips_cpu_info *mips_cpu_info_from_isa (int);
1139 static const struct mips_cpu_info *mips_cpu_info_from_arch (int);
1140 \f
1141 /* Pseudo-op table.
1142
1143    The following pseudo-ops from the Kane and Heinrich MIPS book
1144    should be defined here, but are currently unsupported: .alias,
1145    .galive, .gjaldef, .gjrlive, .livereg, .noalias.
1146
1147    The following pseudo-ops from the Kane and Heinrich MIPS book are
1148    specific to the type of debugging information being generated, and
1149    should be defined by the object format: .aent, .begin, .bend,
1150    .bgnb, .end, .endb, .ent, .fmask, .frame, .loc, .mask, .verstamp,
1151    .vreg.
1152
1153    The following pseudo-ops from the Kane and Heinrich MIPS book are
1154    not MIPS CPU specific, but are also not specific to the object file
1155    format.  This file is probably the best place to define them, but
1156    they are not currently supported: .asm0, .endr, .lab, .struct.  */
1157
1158 static const pseudo_typeS mips_pseudo_table[] =
1159 {
1160   /* MIPS specific pseudo-ops.  */
1161   {"option", s_option, 0},
1162   {"set", s_mipsset, 0},
1163   {"rdata", s_change_sec, 'r'},
1164   {"sdata", s_change_sec, 's'},
1165   {"livereg", s_ignore, 0},
1166   {"abicalls", s_abicalls, 0},
1167   {"cpload", s_cpload, 0},
1168   {"cpsetup", s_cpsetup, 0},
1169   {"cplocal", s_cplocal, 0},
1170   {"cprestore", s_cprestore, 0},
1171   {"cpreturn", s_cpreturn, 0},
1172   {"dtprelword", s_dtprelword, 0},
1173   {"dtpreldword", s_dtpreldword, 0},
1174   {"gpvalue", s_gpvalue, 0},
1175   {"gpword", s_gpword, 0},
1176   {"gpdword", s_gpdword, 0},
1177   {"cpadd", s_cpadd, 0},
1178   {"insn", s_insn, 0},
1179
1180   /* Relatively generic pseudo-ops that happen to be used on MIPS
1181      chips.  */
1182   {"asciiz", stringer, 8 + 1},
1183   {"bss", s_change_sec, 'b'},
1184   {"err", s_err, 0},
1185   {"half", s_cons, 1},
1186   {"dword", s_cons, 3},
1187   {"weakext", s_mips_weakext, 0},
1188   {"origin", s_org, 0},
1189   {"repeat", s_rept, 0},
1190
1191   /* For MIPS this is non-standard, but we define it for consistency.  */
1192   {"sbss", s_change_sec, 'B'},
1193
1194   /* These pseudo-ops are defined in read.c, but must be overridden
1195      here for one reason or another.  */
1196   {"align", s_align, 0},
1197   {"byte", s_cons, 0},
1198   {"data", s_change_sec, 'd'},
1199   {"double", s_float_cons, 'd'},
1200   {"float", s_float_cons, 'f'},
1201   {"globl", s_mips_globl, 0},
1202   {"global", s_mips_globl, 0},
1203   {"hword", s_cons, 1},
1204   {"int", s_cons, 2},
1205   {"long", s_cons, 2},
1206   {"octa", s_cons, 4},
1207   {"quad", s_cons, 3},
1208   {"section", s_change_section, 0},
1209   {"short", s_cons, 1},
1210   {"single", s_float_cons, 'f'},
1211   {"stabn", s_mips_stab, 'n'},
1212   {"text", s_change_sec, 't'},
1213   {"word", s_cons, 2},
1214
1215   { "extern", ecoff_directive_extern, 0},
1216
1217   { NULL, NULL, 0 },
1218 };
1219
1220 static const pseudo_typeS mips_nonecoff_pseudo_table[] =
1221 {
1222   /* These pseudo-ops should be defined by the object file format.
1223      However, a.out doesn't support them, so we have versions here.  */
1224   {"aent", s_mips_ent, 1},
1225   {"bgnb", s_ignore, 0},
1226   {"end", s_mips_end, 0},
1227   {"endb", s_ignore, 0},
1228   {"ent", s_mips_ent, 0},
1229   {"file", s_mips_file, 0},
1230   {"fmask", s_mips_mask, 'F'},
1231   {"frame", s_mips_frame, 0},
1232   {"loc", s_mips_loc, 0},
1233   {"mask", s_mips_mask, 'R'},
1234   {"verstamp", s_ignore, 0},
1235   { NULL, NULL, 0 },
1236 };
1237
1238 extern void pop_insert (const pseudo_typeS *);
1239
1240 void
1241 mips_pop_insert (void)
1242 {
1243   pop_insert (mips_pseudo_table);
1244   if (! ECOFF_DEBUGGING)
1245     pop_insert (mips_nonecoff_pseudo_table);
1246 }
1247 \f
1248 /* Symbols labelling the current insn.  */
1249
1250 struct insn_label_list
1251 {
1252   struct insn_label_list *next;
1253   symbolS *label;
1254 };
1255
1256 static struct insn_label_list *free_insn_labels;
1257 #define label_list tc_segment_info_data.labels
1258
1259 static void mips_clear_insn_labels (void);
1260
1261 static inline void
1262 mips_clear_insn_labels (void)
1263 {
1264   register struct insn_label_list **pl;
1265   segment_info_type *si;
1266
1267   if (now_seg)
1268     {
1269       for (pl = &free_insn_labels; *pl != NULL; pl = &(*pl)->next)
1270         ;
1271       
1272       si = seg_info (now_seg);
1273       *pl = si->label_list;
1274       si->label_list = NULL;
1275     }
1276 }
1277
1278 \f
1279 static char *expr_end;
1280
1281 /* Expressions which appear in instructions.  These are set by
1282    mips_ip.  */
1283
1284 static expressionS imm_expr;
1285 static expressionS imm2_expr;
1286 static expressionS offset_expr;
1287
1288 /* Relocs associated with imm_expr and offset_expr.  */
1289
1290 static bfd_reloc_code_real_type imm_reloc[3]
1291   = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
1292 static bfd_reloc_code_real_type offset_reloc[3]
1293   = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
1294
1295 /* These are set by mips16_ip if an explicit extension is used.  */
1296
1297 static bfd_boolean mips16_small, mips16_ext;
1298
1299 #ifdef OBJ_ELF
1300 /* The pdr segment for per procedure frame/regmask info.  Not used for
1301    ECOFF debugging.  */
1302
1303 static segT pdr_seg;
1304 #endif
1305
1306 /* The default target format to use.  */
1307
1308 const char *
1309 mips_target_format (void)
1310 {
1311   switch (OUTPUT_FLAVOR)
1312     {
1313     case bfd_target_ecoff_flavour:
1314       return target_big_endian ? "ecoff-bigmips" : ECOFF_LITTLE_FORMAT;
1315     case bfd_target_coff_flavour:
1316       return "pe-mips";
1317     case bfd_target_elf_flavour:
1318 #ifdef TE_VXWORKS
1319       if (!HAVE_64BIT_OBJECTS && !HAVE_NEWABI)
1320         return (target_big_endian
1321                 ? "elf32-bigmips-vxworks"
1322                 : "elf32-littlemips-vxworks");
1323 #endif
1324 #ifdef TE_TMIPS
1325       /* This is traditional mips.  */
1326       return (target_big_endian
1327               ? (HAVE_64BIT_OBJECTS
1328                  ? "elf64-tradbigmips"
1329                  : (HAVE_NEWABI
1330                     ? "elf32-ntradbigmips" : "elf32-tradbigmips"))
1331               : (HAVE_64BIT_OBJECTS
1332                  ? "elf64-tradlittlemips"
1333                  : (HAVE_NEWABI
1334                     ? "elf32-ntradlittlemips" : "elf32-tradlittlemips")));
1335 #else
1336       return (target_big_endian
1337               ? (HAVE_64BIT_OBJECTS
1338                  ? "elf64-bigmips"
1339                  : (HAVE_NEWABI
1340                     ? "elf32-nbigmips" : "elf32-bigmips"))
1341               : (HAVE_64BIT_OBJECTS
1342                  ? "elf64-littlemips"
1343                  : (HAVE_NEWABI
1344                     ? "elf32-nlittlemips" : "elf32-littlemips")));
1345 #endif
1346     default:
1347       abort ();
1348       return NULL;
1349     }
1350 }
1351
1352 /* Return the length of instruction INSN.  */
1353
1354 static inline unsigned int
1355 insn_length (const struct mips_cl_insn *insn)
1356 {
1357   if (!mips_opts.mips16)
1358     return 4;
1359   return insn->mips16_absolute_jump_p || insn->use_extend ? 4 : 2;
1360 }
1361
1362 /* Initialise INSN from opcode entry MO.  Leave its position unspecified.  */
1363
1364 static void
1365 create_insn (struct mips_cl_insn *insn, const struct mips_opcode *mo)
1366 {
1367   size_t i;
1368
1369   insn->insn_mo = mo;
1370   insn->use_extend = FALSE;
1371   insn->extend = 0;
1372   insn->insn_opcode = mo->match;
1373   insn->frag = NULL;
1374   insn->where = 0;
1375   for (i = 0; i < ARRAY_SIZE (insn->fixp); i++)
1376     insn->fixp[i] = NULL;
1377   insn->fixed_p = (mips_opts.noreorder > 0);
1378   insn->noreorder_p = (mips_opts.noreorder > 0);
1379   insn->mips16_absolute_jump_p = 0;
1380 }
1381
1382 /* Record the current MIPS16 mode in now_seg.  */
1383
1384 static void
1385 mips_record_mips16_mode (void)
1386 {
1387   segment_info_type *si;
1388
1389   si = seg_info (now_seg);
1390   if (si->tc_segment_info_data.mips16 != mips_opts.mips16)
1391     si->tc_segment_info_data.mips16 = mips_opts.mips16;
1392 }
1393
1394 /* Install INSN at the location specified by its "frag" and "where" fields.  */
1395
1396 static void
1397 install_insn (const struct mips_cl_insn *insn)
1398 {
1399   char *f = insn->frag->fr_literal + insn->where;
1400   if (!mips_opts.mips16)
1401     md_number_to_chars (f, insn->insn_opcode, 4);
1402   else if (insn->mips16_absolute_jump_p)
1403     {
1404       md_number_to_chars (f, insn->insn_opcode >> 16, 2);
1405       md_number_to_chars (f + 2, insn->insn_opcode & 0xffff, 2);
1406     }
1407   else
1408     {
1409       if (insn->use_extend)
1410         {
1411           md_number_to_chars (f, 0xf000 | insn->extend, 2);
1412           f += 2;
1413         }
1414       md_number_to_chars (f, insn->insn_opcode, 2);
1415     }
1416   mips_record_mips16_mode ();
1417 }
1418
1419 /* Move INSN to offset WHERE in FRAG.  Adjust the fixups accordingly
1420    and install the opcode in the new location.  */
1421
1422 static void
1423 move_insn (struct mips_cl_insn *insn, fragS *frag, long where)
1424 {
1425   size_t i;
1426
1427   insn->frag = frag;
1428   insn->where = where;
1429   for (i = 0; i < ARRAY_SIZE (insn->fixp); i++)
1430     if (insn->fixp[i] != NULL)
1431       {
1432         insn->fixp[i]->fx_frag = frag;
1433         insn->fixp[i]->fx_where = where;
1434       }
1435   install_insn (insn);
1436 }
1437
1438 /* Add INSN to the end of the output.  */
1439
1440 static void
1441 add_fixed_insn (struct mips_cl_insn *insn)
1442 {
1443   char *f = frag_more (insn_length (insn));
1444   move_insn (insn, frag_now, f - frag_now->fr_literal);
1445 }
1446
1447 /* Start a variant frag and move INSN to the start of the variant part,
1448    marking it as fixed.  The other arguments are as for frag_var.  */
1449
1450 static void
1451 add_relaxed_insn (struct mips_cl_insn *insn, int max_chars, int var,
1452                   relax_substateT subtype, symbolS *symbol, offsetT offset)
1453 {
1454   frag_grow (max_chars);
1455   move_insn (insn, frag_now, frag_more (0) - frag_now->fr_literal);
1456   insn->fixed_p = 1;
1457   frag_var (rs_machine_dependent, max_chars, var,
1458             subtype, symbol, offset, NULL);
1459 }
1460
1461 /* Insert N copies of INSN into the history buffer, starting at
1462    position FIRST.  Neither FIRST nor N need to be clipped.  */
1463
1464 static void
1465 insert_into_history (unsigned int first, unsigned int n,
1466                      const struct mips_cl_insn *insn)
1467 {
1468   if (mips_relax.sequence != 2)
1469     {
1470       unsigned int i;
1471
1472       for (i = ARRAY_SIZE (history); i-- > first;)
1473         if (i >= first + n)
1474           history[i] = history[i - n];
1475         else
1476           history[i] = *insn;
1477     }
1478 }
1479
1480 /* Emit a nop instruction, recording it in the history buffer.  */
1481
1482 static void
1483 emit_nop (void)
1484 {
1485   add_fixed_insn (NOP_INSN);
1486   insert_into_history (0, 1, NOP_INSN);
1487 }
1488
1489 /* Initialize vr4120_conflicts.  There is a bit of duplication here:
1490    the idea is to make it obvious at a glance that each errata is
1491    included.  */
1492
1493 static void
1494 init_vr4120_conflicts (void)
1495 {
1496 #define CONFLICT(FIRST, SECOND) \
1497     vr4120_conflicts[FIX_VR4120_##FIRST] |= 1 << FIX_VR4120_##SECOND
1498
1499   /* Errata 21 - [D]DIV[U] after [D]MACC */
1500   CONFLICT (MACC, DIV);
1501   CONFLICT (DMACC, DIV);
1502
1503   /* Errata 23 - Continuous DMULT[U]/DMACC instructions.  */
1504   CONFLICT (DMULT, DMULT);
1505   CONFLICT (DMULT, DMACC);
1506   CONFLICT (DMACC, DMULT);
1507   CONFLICT (DMACC, DMACC);
1508
1509   /* Errata 24 - MT{LO,HI} after [D]MACC */
1510   CONFLICT (MACC, MTHILO);
1511   CONFLICT (DMACC, MTHILO);
1512
1513   /* VR4181A errata MD(1): "If a MULT, MULTU, DMULT or DMULTU
1514      instruction is executed immediately after a MACC or DMACC
1515      instruction, the result of [either instruction] is incorrect."  */
1516   CONFLICT (MACC, MULT);
1517   CONFLICT (MACC, DMULT);
1518   CONFLICT (DMACC, MULT);
1519   CONFLICT (DMACC, DMULT);
1520
1521   /* VR4181A errata MD(4): "If a MACC or DMACC instruction is
1522      executed immediately after a DMULT, DMULTU, DIV, DIVU,
1523      DDIV or DDIVU instruction, the result of the MACC or
1524      DMACC instruction is incorrect.".  */
1525   CONFLICT (DMULT, MACC);
1526   CONFLICT (DMULT, DMACC);
1527   CONFLICT (DIV, MACC);
1528   CONFLICT (DIV, DMACC);
1529
1530 #undef CONFLICT
1531 }
1532
1533 struct regname {
1534   const char *name;
1535   unsigned int num;
1536 };
1537
1538 #define RTYPE_MASK      0x1ff00
1539 #define RTYPE_NUM       0x00100
1540 #define RTYPE_FPU       0x00200
1541 #define RTYPE_FCC       0x00400
1542 #define RTYPE_VEC       0x00800
1543 #define RTYPE_GP        0x01000
1544 #define RTYPE_CP0       0x02000
1545 #define RTYPE_PC        0x04000
1546 #define RTYPE_ACC       0x08000
1547 #define RTYPE_CCC       0x10000
1548 #define RNUM_MASK       0x000ff
1549 #define RWARN           0x80000
1550
1551 #define GENERIC_REGISTER_NUMBERS \
1552     {"$0",      RTYPE_NUM | 0},  \
1553     {"$1",      RTYPE_NUM | 1},  \
1554     {"$2",      RTYPE_NUM | 2},  \
1555     {"$3",      RTYPE_NUM | 3},  \
1556     {"$4",      RTYPE_NUM | 4},  \
1557     {"$5",      RTYPE_NUM | 5},  \
1558     {"$6",      RTYPE_NUM | 6},  \
1559     {"$7",      RTYPE_NUM | 7},  \
1560     {"$8",      RTYPE_NUM | 8},  \
1561     {"$9",      RTYPE_NUM | 9},  \
1562     {"$10",     RTYPE_NUM | 10}, \
1563     {"$11",     RTYPE_NUM | 11}, \
1564     {"$12",     RTYPE_NUM | 12}, \
1565     {"$13",     RTYPE_NUM | 13}, \
1566     {"$14",     RTYPE_NUM | 14}, \
1567     {"$15",     RTYPE_NUM | 15}, \
1568     {"$16",     RTYPE_NUM | 16}, \
1569     {"$17",     RTYPE_NUM | 17}, \
1570     {"$18",     RTYPE_NUM | 18}, \
1571     {"$19",     RTYPE_NUM | 19}, \
1572     {"$20",     RTYPE_NUM | 20}, \
1573     {"$21",     RTYPE_NUM | 21}, \
1574     {"$22",     RTYPE_NUM | 22}, \
1575     {"$23",     RTYPE_NUM | 23}, \
1576     {"$24",     RTYPE_NUM | 24}, \
1577     {"$25",     RTYPE_NUM | 25}, \
1578     {"$26",     RTYPE_NUM | 26}, \
1579     {"$27",     RTYPE_NUM | 27}, \
1580     {"$28",     RTYPE_NUM | 28}, \
1581     {"$29",     RTYPE_NUM | 29}, \
1582     {"$30",     RTYPE_NUM | 30}, \
1583     {"$31",     RTYPE_NUM | 31} 
1584
1585 #define FPU_REGISTER_NAMES       \
1586     {"$f0",     RTYPE_FPU | 0},  \
1587     {"$f1",     RTYPE_FPU | 1},  \
1588     {"$f2",     RTYPE_FPU | 2},  \
1589     {"$f3",     RTYPE_FPU | 3},  \
1590     {"$f4",     RTYPE_FPU | 4},  \
1591     {"$f5",     RTYPE_FPU | 5},  \
1592     {"$f6",     RTYPE_FPU | 6},  \
1593     {"$f7",     RTYPE_FPU | 7},  \
1594     {"$f8",     RTYPE_FPU | 8},  \
1595     {"$f9",     RTYPE_FPU | 9},  \
1596     {"$f10",    RTYPE_FPU | 10}, \
1597     {"$f11",    RTYPE_FPU | 11}, \
1598     {"$f12",    RTYPE_FPU | 12}, \
1599     {"$f13",    RTYPE_FPU | 13}, \
1600     {"$f14",    RTYPE_FPU | 14}, \
1601     {"$f15",    RTYPE_FPU | 15}, \
1602     {"$f16",    RTYPE_FPU | 16}, \
1603     {"$f17",    RTYPE_FPU | 17}, \
1604     {"$f18",    RTYPE_FPU | 18}, \
1605     {"$f19",    RTYPE_FPU | 19}, \
1606     {"$f20",    RTYPE_FPU | 20}, \
1607     {"$f21",    RTYPE_FPU | 21}, \
1608     {"$f22",    RTYPE_FPU | 22}, \
1609     {"$f23",    RTYPE_FPU | 23}, \
1610     {"$f24",    RTYPE_FPU | 24}, \
1611     {"$f25",    RTYPE_FPU | 25}, \
1612     {"$f26",    RTYPE_FPU | 26}, \
1613     {"$f27",    RTYPE_FPU | 27}, \
1614     {"$f28",    RTYPE_FPU | 28}, \
1615     {"$f29",    RTYPE_FPU | 29}, \
1616     {"$f30",    RTYPE_FPU | 30}, \
1617     {"$f31",    RTYPE_FPU | 31}
1618
1619 #define FPU_CONDITION_CODE_NAMES \
1620     {"$fcc0",   RTYPE_FCC | 0},  \
1621     {"$fcc1",   RTYPE_FCC | 1},  \
1622     {"$fcc2",   RTYPE_FCC | 2},  \
1623     {"$fcc3",   RTYPE_FCC | 3},  \
1624     {"$fcc4",   RTYPE_FCC | 4},  \
1625     {"$fcc5",   RTYPE_FCC | 5},  \
1626     {"$fcc6",   RTYPE_FCC | 6},  \
1627     {"$fcc7",   RTYPE_FCC | 7}
1628
1629 #define COPROC_CONDITION_CODE_NAMES         \
1630     {"$cc0",    RTYPE_FCC | RTYPE_CCC | 0}, \
1631     {"$cc1",    RTYPE_FCC | RTYPE_CCC | 1}, \
1632     {"$cc2",    RTYPE_FCC | RTYPE_CCC | 2}, \
1633     {"$cc3",    RTYPE_FCC | RTYPE_CCC | 3}, \
1634     {"$cc4",    RTYPE_FCC | RTYPE_CCC | 4}, \
1635     {"$cc5",    RTYPE_FCC | RTYPE_CCC | 5}, \
1636     {"$cc6",    RTYPE_FCC | RTYPE_CCC | 6}, \
1637     {"$cc7",    RTYPE_FCC | RTYPE_CCC | 7}
1638
1639 #define N32N64_SYMBOLIC_REGISTER_NAMES \
1640     {"$a4",     RTYPE_GP | 8},  \
1641     {"$a5",     RTYPE_GP | 9},  \
1642     {"$a6",     RTYPE_GP | 10}, \
1643     {"$a7",     RTYPE_GP | 11}, \
1644     {"$ta0",    RTYPE_GP | 8},  /* alias for $a4 */ \
1645     {"$ta1",    RTYPE_GP | 9},  /* alias for $a5 */ \
1646     {"$ta2",    RTYPE_GP | 10}, /* alias for $a6 */ \
1647     {"$ta3",    RTYPE_GP | 11}, /* alias for $a7 */ \
1648     {"$t0",     RTYPE_GP | 12}, \
1649     {"$t1",     RTYPE_GP | 13}, \
1650     {"$t2",     RTYPE_GP | 14}, \
1651     {"$t3",     RTYPE_GP | 15}
1652
1653 #define O32_SYMBOLIC_REGISTER_NAMES \
1654     {"$t0",     RTYPE_GP | 8},  \
1655     {"$t1",     RTYPE_GP | 9},  \
1656     {"$t2",     RTYPE_GP | 10}, \
1657     {"$t3",     RTYPE_GP | 11}, \
1658     {"$t4",     RTYPE_GP | 12}, \
1659     {"$t5",     RTYPE_GP | 13}, \
1660     {"$t6",     RTYPE_GP | 14}, \
1661     {"$t7",     RTYPE_GP | 15}, \
1662     {"$ta0",    RTYPE_GP | 12}, /* alias for $t4 */ \
1663     {"$ta1",    RTYPE_GP | 13}, /* alias for $t5 */ \
1664     {"$ta2",    RTYPE_GP | 14}, /* alias for $t6 */ \
1665     {"$ta3",    RTYPE_GP | 15}  /* alias for $t7 */ 
1666
1667 /* Remaining symbolic register names */
1668 #define SYMBOLIC_REGISTER_NAMES \
1669     {"$zero",   RTYPE_GP | 0},  \
1670     {"$at",     RTYPE_GP | 1},  \
1671     {"$AT",     RTYPE_GP | 1},  \
1672     {"$v0",     RTYPE_GP | 2},  \
1673     {"$v1",     RTYPE_GP | 3},  \
1674     {"$a0",     RTYPE_GP | 4},  \
1675     {"$a1",     RTYPE_GP | 5},  \
1676     {"$a2",     RTYPE_GP | 6},  \
1677     {"$a3",     RTYPE_GP | 7},  \
1678     {"$s0",     RTYPE_GP | 16}, \
1679     {"$s1",     RTYPE_GP | 17}, \
1680     {"$s2",     RTYPE_GP | 18}, \
1681     {"$s3",     RTYPE_GP | 19}, \
1682     {"$s4",     RTYPE_GP | 20}, \
1683     {"$s5",     RTYPE_GP | 21}, \
1684     {"$s6",     RTYPE_GP | 22}, \
1685     {"$s7",     RTYPE_GP | 23}, \
1686     {"$t8",     RTYPE_GP | 24}, \
1687     {"$t9",     RTYPE_GP | 25}, \
1688     {"$k0",     RTYPE_GP | 26}, \
1689     {"$kt0",    RTYPE_GP | 26}, \
1690     {"$k1",     RTYPE_GP | 27}, \
1691     {"$kt1",    RTYPE_GP | 27}, \
1692     {"$gp",     RTYPE_GP | 28}, \
1693     {"$sp",     RTYPE_GP | 29}, \
1694     {"$s8",     RTYPE_GP | 30}, \
1695     {"$fp",     RTYPE_GP | 30}, \
1696     {"$ra",     RTYPE_GP | 31}
1697
1698 #define MIPS16_SPECIAL_REGISTER_NAMES \
1699     {"$pc",     RTYPE_PC | 0}
1700
1701 #define MDMX_VECTOR_REGISTER_NAMES \
1702     /* {"$v0",  RTYPE_VEC | 0},  clash with REG 2 above */ \
1703     /* {"$v1",  RTYPE_VEC | 1},  clash with REG 3 above */ \
1704     {"$v2",     RTYPE_VEC | 2},  \
1705     {"$v3",     RTYPE_VEC | 3},  \
1706     {"$v4",     RTYPE_VEC | 4},  \
1707     {"$v5",     RTYPE_VEC | 5},  \
1708     {"$v6",     RTYPE_VEC | 6},  \
1709     {"$v7",     RTYPE_VEC | 7},  \
1710     {"$v8",     RTYPE_VEC | 8},  \
1711     {"$v9",     RTYPE_VEC | 9},  \
1712     {"$v10",    RTYPE_VEC | 10}, \
1713     {"$v11",    RTYPE_VEC | 11}, \
1714     {"$v12",    RTYPE_VEC | 12}, \
1715     {"$v13",    RTYPE_VEC | 13}, \
1716     {"$v14",    RTYPE_VEC | 14}, \
1717     {"$v15",    RTYPE_VEC | 15}, \
1718     {"$v16",    RTYPE_VEC | 16}, \
1719     {"$v17",    RTYPE_VEC | 17}, \
1720     {"$v18",    RTYPE_VEC | 18}, \
1721     {"$v19",    RTYPE_VEC | 19}, \
1722     {"$v20",    RTYPE_VEC | 20}, \
1723     {"$v21",    RTYPE_VEC | 21}, \
1724     {"$v22",    RTYPE_VEC | 22}, \
1725     {"$v23",    RTYPE_VEC | 23}, \
1726     {"$v24",    RTYPE_VEC | 24}, \
1727     {"$v25",    RTYPE_VEC | 25}, \
1728     {"$v26",    RTYPE_VEC | 26}, \
1729     {"$v27",    RTYPE_VEC | 27}, \
1730     {"$v28",    RTYPE_VEC | 28}, \
1731     {"$v29",    RTYPE_VEC | 29}, \
1732     {"$v30",    RTYPE_VEC | 30}, \
1733     {"$v31",    RTYPE_VEC | 31}
1734
1735 #define MIPS_DSP_ACCUMULATOR_NAMES \
1736     {"$ac0",    RTYPE_ACC | 0}, \
1737     {"$ac1",    RTYPE_ACC | 1}, \
1738     {"$ac2",    RTYPE_ACC | 2}, \
1739     {"$ac3",    RTYPE_ACC | 3}
1740
1741 static const struct regname reg_names[] = {
1742   GENERIC_REGISTER_NUMBERS,
1743   FPU_REGISTER_NAMES,
1744   FPU_CONDITION_CODE_NAMES,
1745   COPROC_CONDITION_CODE_NAMES,
1746
1747   /* The $txx registers depends on the abi,
1748      these will be added later into the symbol table from
1749      one of the tables below once mips_abi is set after 
1750      parsing of arguments from the command line. */
1751   SYMBOLIC_REGISTER_NAMES,
1752
1753   MIPS16_SPECIAL_REGISTER_NAMES,
1754   MDMX_VECTOR_REGISTER_NAMES,
1755   MIPS_DSP_ACCUMULATOR_NAMES,
1756   {0, 0}
1757 };
1758
1759 static const struct regname reg_names_o32[] = {
1760   O32_SYMBOLIC_REGISTER_NAMES,
1761   {0, 0}
1762 };
1763
1764 static const struct regname reg_names_n32n64[] = {
1765   N32N64_SYMBOLIC_REGISTER_NAMES,
1766   {0, 0}
1767 };
1768
1769 static int
1770 reg_lookup (char **s, unsigned int types, unsigned int *regnop)
1771 {
1772   symbolS *symbolP;
1773   char *e;
1774   char save_c;
1775   int reg = -1;
1776
1777   /* Find end of name.  */
1778   e = *s;
1779   if (is_name_beginner (*e))
1780     ++e;
1781   while (is_part_of_name (*e))
1782     ++e;
1783
1784   /* Terminate name.  */
1785   save_c = *e;
1786   *e = '\0';
1787
1788   /* Look for a register symbol.  */
1789   if ((symbolP = symbol_find (*s)) && S_GET_SEGMENT (symbolP) == reg_section)
1790     {
1791       int r = S_GET_VALUE (symbolP);
1792       if (r & types)
1793         reg = r & RNUM_MASK;
1794       else if ((types & RTYPE_VEC) && (r & ~1) == (RTYPE_GP | 2))
1795         /* Convert GP reg $v0/1 to MDMX reg $v0/1!  */
1796         reg = (r & RNUM_MASK) - 2;
1797     }
1798   /* Else see if this is a register defined in an itbl entry.  */
1799   else if ((types & RTYPE_GP) && itbl_have_entries)
1800     {
1801       char *n = *s;
1802       unsigned long r;
1803
1804       if (*n == '$')
1805         ++n;
1806       if (itbl_get_reg_val (n, &r))
1807         reg = r & RNUM_MASK;
1808     }
1809
1810   /* Advance to next token if a register was recognised.  */
1811   if (reg >= 0)
1812     *s = e;
1813   else if (types & RWARN)
1814     as_warn (_("Unrecognized register name `%s'"), *s);
1815
1816   *e = save_c;
1817   if (regnop)
1818     *regnop = reg;
1819   return reg >= 0;
1820 }
1821
1822 /* Return TRUE if opcode MO is valid on the currently selected ISA and
1823    architecture.  Use is_opcode_valid_16 for MIPS16 opcodes.  */
1824
1825 static bfd_boolean
1826 is_opcode_valid (const struct mips_opcode *mo)
1827 {
1828   int isa = mips_opts.isa;
1829   int fp_s, fp_d;
1830
1831   if (mips_opts.ase_mdmx)
1832     isa |= INSN_MDMX;
1833   if (mips_opts.ase_dsp)
1834     isa |= INSN_DSP;
1835   if (mips_opts.ase_dsp && ISA_SUPPORTS_DSP64_ASE)
1836     isa |= INSN_DSP64;
1837   if (mips_opts.ase_dspr2)
1838     isa |= INSN_DSPR2;
1839   if (mips_opts.ase_mt)
1840     isa |= INSN_MT;
1841   if (mips_opts.ase_mips3d)
1842     isa |= INSN_MIPS3D;
1843   if (mips_opts.ase_smartmips)
1844     isa |= INSN_SMARTMIPS;
1845
1846   /* Don't accept instructions based on the ISA if the CPU does not implement
1847      all the coprocessor insns. */
1848   if (NO_ISA_COP (mips_opts.arch)
1849       && COP_INSN (mo->pinfo))
1850     isa = 0;
1851
1852   if (!OPCODE_IS_MEMBER (mo, isa, mips_opts.arch))
1853     return FALSE;
1854
1855   /* Check whether the instruction or macro requires single-precision or
1856      double-precision floating-point support.  Note that this information is
1857      stored differently in the opcode table for insns and macros.  */
1858   if (mo->pinfo == INSN_MACRO)
1859     {
1860       fp_s = mo->pinfo2 & INSN2_M_FP_S;
1861       fp_d = mo->pinfo2 & INSN2_M_FP_D;
1862     }
1863   else
1864     {
1865       fp_s = mo->pinfo & FP_S;
1866       fp_d = mo->pinfo & FP_D;
1867     }
1868
1869   if (fp_d && (mips_opts.soft_float || mips_opts.single_float))
1870     return FALSE;
1871
1872   if (fp_s && mips_opts.soft_float)
1873     return FALSE;
1874
1875   return TRUE;
1876 }
1877
1878 /* Return TRUE if the MIPS16 opcode MO is valid on the currently
1879    selected ISA and architecture.  */
1880
1881 static bfd_boolean
1882 is_opcode_valid_16 (const struct mips_opcode *mo)
1883 {
1884   return OPCODE_IS_MEMBER (mo, mips_opts.isa, mips_opts.arch) ? TRUE : FALSE;
1885 }
1886
1887 /* This function is called once, at assembler startup time.  It should set up
1888    all the tables, etc. that the MD part of the assembler will need.  */
1889
1890 void
1891 md_begin (void)
1892 {
1893   const char *retval = NULL;
1894   int i = 0;
1895   int broken = 0;
1896
1897   if (mips_pic != NO_PIC)
1898     {
1899       if (g_switch_seen && g_switch_value != 0)
1900         as_bad (_("-G may not be used in position-independent code"));
1901       g_switch_value = 0;
1902     }
1903
1904   if (! bfd_set_arch_mach (stdoutput, bfd_arch_mips, file_mips_arch))
1905     as_warn (_("Could not set architecture and machine"));
1906
1907   op_hash = hash_new ();
1908
1909   for (i = 0; i < NUMOPCODES;)
1910     {
1911       const char *name = mips_opcodes[i].name;
1912
1913       retval = hash_insert (op_hash, name, (void *) &mips_opcodes[i]);
1914       if (retval != NULL)
1915         {
1916           fprintf (stderr, _("internal error: can't hash `%s': %s\n"),
1917                    mips_opcodes[i].name, retval);
1918           /* Probably a memory allocation problem?  Give up now.  */
1919           as_fatal (_("Broken assembler.  No assembly attempted."));
1920         }
1921       do
1922         {
1923           if (mips_opcodes[i].pinfo != INSN_MACRO)
1924             {
1925               if (!validate_mips_insn (&mips_opcodes[i]))
1926                 broken = 1;
1927               if (nop_insn.insn_mo == NULL && strcmp (name, "nop") == 0)
1928                 {
1929                   create_insn (&nop_insn, mips_opcodes + i);
1930                   if (mips_fix_loongson2f_nop)
1931                     nop_insn.insn_opcode = LOONGSON2F_NOP_INSN;
1932                   nop_insn.fixed_p = 1;
1933                 }
1934             }
1935           ++i;
1936         }
1937       while ((i < NUMOPCODES) && !strcmp (mips_opcodes[i].name, name));
1938     }
1939
1940   mips16_op_hash = hash_new ();
1941
1942   i = 0;
1943   while (i < bfd_mips16_num_opcodes)
1944     {
1945       const char *name = mips16_opcodes[i].name;
1946
1947       retval = hash_insert (mips16_op_hash, name, (void *) &mips16_opcodes[i]);
1948       if (retval != NULL)
1949         as_fatal (_("internal: can't hash `%s': %s"),
1950                   mips16_opcodes[i].name, retval);
1951       do
1952         {
1953           if (mips16_opcodes[i].pinfo != INSN_MACRO
1954               && ((mips16_opcodes[i].match & mips16_opcodes[i].mask)
1955                   != mips16_opcodes[i].match))
1956             {
1957               fprintf (stderr, _("internal error: bad mips16 opcode: %s %s\n"),
1958                        mips16_opcodes[i].name, mips16_opcodes[i].args);
1959               broken = 1;
1960             }
1961           if (mips16_nop_insn.insn_mo == NULL && strcmp (name, "nop") == 0)
1962             {
1963               create_insn (&mips16_nop_insn, mips16_opcodes + i);
1964               mips16_nop_insn.fixed_p = 1;
1965             }
1966           ++i;
1967         }
1968       while (i < bfd_mips16_num_opcodes
1969              && strcmp (mips16_opcodes[i].name, name) == 0);
1970     }
1971
1972   if (broken)
1973     as_fatal (_("Broken assembler.  No assembly attempted."));
1974
1975   /* We add all the general register names to the symbol table.  This
1976      helps us detect invalid uses of them.  */
1977   for (i = 0; reg_names[i].name; i++) 
1978     symbol_table_insert (symbol_new (reg_names[i].name, reg_section,
1979                                      reg_names[i].num, /* & RNUM_MASK, */
1980                                      &zero_address_frag));
1981   if (HAVE_NEWABI)
1982     for (i = 0; reg_names_n32n64[i].name; i++) 
1983       symbol_table_insert (symbol_new (reg_names_n32n64[i].name, reg_section,
1984                                        reg_names_n32n64[i].num, /* & RNUM_MASK, */
1985                                        &zero_address_frag));
1986   else
1987     for (i = 0; reg_names_o32[i].name; i++) 
1988       symbol_table_insert (symbol_new (reg_names_o32[i].name, reg_section,
1989                                        reg_names_o32[i].num, /* & RNUM_MASK, */
1990                                        &zero_address_frag));
1991
1992   mips_no_prev_insn ();
1993
1994   mips_gprmask = 0;
1995   mips_cprmask[0] = 0;
1996   mips_cprmask[1] = 0;
1997   mips_cprmask[2] = 0;
1998   mips_cprmask[3] = 0;
1999
2000   /* set the default alignment for the text section (2**2) */
2001   record_alignment (text_section, 2);
2002
2003   bfd_set_gp_size (stdoutput, g_switch_value);
2004
2005 #ifdef OBJ_ELF
2006   if (IS_ELF)
2007     {
2008       /* On a native system other than VxWorks, sections must be aligned
2009          to 16 byte boundaries.  When configured for an embedded ELF
2010          target, we don't bother.  */
2011       if (strncmp (TARGET_OS, "elf", 3) != 0
2012           && strncmp (TARGET_OS, "vxworks", 7) != 0)
2013         {
2014           (void) bfd_set_section_alignment (stdoutput, text_section, 4);
2015           (void) bfd_set_section_alignment (stdoutput, data_section, 4);
2016           (void) bfd_set_section_alignment (stdoutput, bss_section, 4);
2017         }
2018
2019       /* Create a .reginfo section for register masks and a .mdebug
2020          section for debugging information.  */
2021       {
2022         segT seg;
2023         subsegT subseg;
2024         flagword flags;
2025         segT sec;
2026
2027         seg = now_seg;
2028         subseg = now_subseg;
2029
2030         /* The ABI says this section should be loaded so that the
2031            running program can access it.  However, we don't load it
2032            if we are configured for an embedded target */
2033         flags = SEC_READONLY | SEC_DATA;
2034         if (strncmp (TARGET_OS, "elf", 3) != 0)
2035           flags |= SEC_ALLOC | SEC_LOAD;
2036
2037         if (mips_abi != N64_ABI)
2038           {
2039             sec = subseg_new (".reginfo", (subsegT) 0);
2040
2041             bfd_set_section_flags (stdoutput, sec, flags);
2042             bfd_set_section_alignment (stdoutput, sec, HAVE_NEWABI ? 3 : 2);
2043
2044             mips_regmask_frag = frag_more (sizeof (Elf32_External_RegInfo));
2045           }
2046         else
2047           {
2048             /* The 64-bit ABI uses a .MIPS.options section rather than
2049                .reginfo section.  */
2050             sec = subseg_new (".MIPS.options", (subsegT) 0);
2051             bfd_set_section_flags (stdoutput, sec, flags);
2052             bfd_set_section_alignment (stdoutput, sec, 3);
2053
2054             /* Set up the option header.  */
2055             {
2056               Elf_Internal_Options opthdr;
2057               char *f;
2058
2059               opthdr.kind = ODK_REGINFO;
2060               opthdr.size = (sizeof (Elf_External_Options)
2061                              + sizeof (Elf64_External_RegInfo));
2062               opthdr.section = 0;
2063               opthdr.info = 0;
2064               f = frag_more (sizeof (Elf_External_Options));
2065               bfd_mips_elf_swap_options_out (stdoutput, &opthdr,
2066                                              (Elf_External_Options *) f);
2067
2068               mips_regmask_frag = frag_more (sizeof (Elf64_External_RegInfo));
2069             }
2070           }
2071
2072         if (ECOFF_DEBUGGING)
2073           {
2074             sec = subseg_new (".mdebug", (subsegT) 0);
2075             (void) bfd_set_section_flags (stdoutput, sec,
2076                                           SEC_HAS_CONTENTS | SEC_READONLY);
2077             (void) bfd_set_section_alignment (stdoutput, sec, 2);
2078           }
2079         else if (mips_flag_pdr)
2080           {
2081             pdr_seg = subseg_new (".pdr", (subsegT) 0);
2082             (void) bfd_set_section_flags (stdoutput, pdr_seg,
2083                                           SEC_READONLY | SEC_RELOC
2084                                           | SEC_DEBUGGING);
2085             (void) bfd_set_section_alignment (stdoutput, pdr_seg, 2);
2086           }
2087
2088         subseg_set (seg, subseg);
2089       }
2090     }
2091 #endif /* OBJ_ELF */
2092
2093   if (! ECOFF_DEBUGGING)
2094     md_obj_begin ();
2095
2096   if (mips_fix_vr4120)
2097     init_vr4120_conflicts ();
2098 }
2099
2100 void
2101 md_mips_end (void)
2102 {
2103   if (! ECOFF_DEBUGGING)
2104     md_obj_end ();
2105 }
2106
2107 void
2108 md_assemble (char *str)
2109 {
2110   struct mips_cl_insn insn;
2111   bfd_reloc_code_real_type unused_reloc[3]
2112     = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
2113
2114   imm_expr.X_op = O_absent;
2115   imm2_expr.X_op = O_absent;
2116   offset_expr.X_op = O_absent;
2117   imm_reloc[0] = BFD_RELOC_UNUSED;
2118   imm_reloc[1] = BFD_RELOC_UNUSED;
2119   imm_reloc[2] = BFD_RELOC_UNUSED;
2120   offset_reloc[0] = BFD_RELOC_UNUSED;
2121   offset_reloc[1] = BFD_RELOC_UNUSED;
2122   offset_reloc[2] = BFD_RELOC_UNUSED;
2123
2124   if (mips_opts.mips16)
2125     mips16_ip (str, &insn);
2126   else
2127     {
2128       mips_ip (str, &insn);
2129       DBG ((_("returned from mips_ip(%s) insn_opcode = 0x%x\n"),
2130             str, insn.insn_opcode));
2131     }
2132
2133   if (insn_error)
2134     {
2135       as_bad ("%s `%s'", insn_error, str);
2136       return;
2137     }
2138
2139   if (insn.insn_mo->pinfo == INSN_MACRO)
2140     {
2141       macro_start ();
2142       if (mips_opts.mips16)
2143         mips16_macro (&insn);
2144       else
2145         macro (&insn);
2146       macro_end ();
2147     }
2148   else
2149     {
2150       if (imm_expr.X_op != O_absent)
2151         append_insn (&insn, &imm_expr, imm_reloc);
2152       else if (offset_expr.X_op != O_absent)
2153         append_insn (&insn, &offset_expr, offset_reloc);
2154       else
2155         append_insn (&insn, NULL, unused_reloc);
2156     }
2157 }
2158
2159 /* Convenience functions for abstracting away the differences between
2160    MIPS16 and non-MIPS16 relocations.  */
2161
2162 static inline bfd_boolean
2163 mips16_reloc_p (bfd_reloc_code_real_type reloc)
2164 {
2165   switch (reloc)
2166     {
2167     case BFD_RELOC_MIPS16_JMP:
2168     case BFD_RELOC_MIPS16_GPREL:
2169     case BFD_RELOC_MIPS16_GOT16:
2170     case BFD_RELOC_MIPS16_CALL16:
2171     case BFD_RELOC_MIPS16_HI16_S:
2172     case BFD_RELOC_MIPS16_HI16:
2173     case BFD_RELOC_MIPS16_LO16:
2174       return TRUE;
2175
2176     default:
2177       return FALSE;
2178     }
2179 }
2180
2181 static inline bfd_boolean
2182 got16_reloc_p (bfd_reloc_code_real_type reloc)
2183 {
2184   return reloc == BFD_RELOC_MIPS_GOT16 || reloc == BFD_RELOC_MIPS16_GOT16;
2185 }
2186
2187 static inline bfd_boolean
2188 hi16_reloc_p (bfd_reloc_code_real_type reloc)
2189 {
2190   return reloc == BFD_RELOC_HI16_S || reloc == BFD_RELOC_MIPS16_HI16_S;
2191 }
2192
2193 static inline bfd_boolean
2194 lo16_reloc_p (bfd_reloc_code_real_type reloc)
2195 {
2196   return reloc == BFD_RELOC_LO16 || reloc == BFD_RELOC_MIPS16_LO16;
2197 }
2198
2199 /* Return true if the given relocation might need a matching %lo().
2200    This is only "might" because SVR4 R_MIPS_GOT16 relocations only
2201    need a matching %lo() when applied to local symbols.  */
2202
2203 static inline bfd_boolean
2204 reloc_needs_lo_p (bfd_reloc_code_real_type reloc)
2205 {
2206   return (HAVE_IN_PLACE_ADDENDS
2207           && (hi16_reloc_p (reloc)
2208               /* VxWorks R_MIPS_GOT16 relocs never need a matching %lo();
2209                  all GOT16 relocations evaluate to "G".  */
2210               || (got16_reloc_p (reloc) && mips_pic != VXWORKS_PIC)));
2211 }
2212
2213 /* Return the type of %lo() reloc needed by RELOC, given that
2214    reloc_needs_lo_p.  */
2215
2216 static inline bfd_reloc_code_real_type
2217 matching_lo_reloc (bfd_reloc_code_real_type reloc)
2218 {
2219   return mips16_reloc_p (reloc) ? BFD_RELOC_MIPS16_LO16 : BFD_RELOC_LO16;
2220 }
2221
2222 /* Return true if the given fixup is followed by a matching R_MIPS_LO16
2223    relocation.  */
2224
2225 static inline bfd_boolean
2226 fixup_has_matching_lo_p (fixS *fixp)
2227 {
2228   return (fixp->fx_next != NULL
2229           && fixp->fx_next->fx_r_type == matching_lo_reloc (fixp->fx_r_type)
2230           && fixp->fx_addsy == fixp->fx_next->fx_addsy
2231           && fixp->fx_offset == fixp->fx_next->fx_offset);
2232 }
2233
2234 /* See whether instruction IP reads register REG.  CLASS is the type
2235    of register.  */
2236
2237 static int
2238 insn_uses_reg (const struct mips_cl_insn *ip, unsigned int reg,
2239                enum mips_regclass regclass)
2240 {
2241   if (regclass == MIPS16_REG)
2242     {
2243       gas_assert (mips_opts.mips16);
2244       reg = mips16_to_32_reg_map[reg];
2245       regclass = MIPS_GR_REG;
2246     }
2247
2248   /* Don't report on general register ZERO, since it never changes.  */
2249   if (regclass == MIPS_GR_REG && reg == ZERO)
2250     return 0;
2251
2252   if (regclass == MIPS_FP_REG)
2253     {
2254       gas_assert (! mips_opts.mips16);
2255       /* If we are called with either $f0 or $f1, we must check $f0.
2256          This is not optimal, because it will introduce an unnecessary
2257          NOP between "lwc1 $f0" and "swc1 $f1".  To fix this we would
2258          need to distinguish reading both $f0 and $f1 or just one of
2259          them.  Note that we don't have to check the other way,
2260          because there is no instruction that sets both $f0 and $f1
2261          and requires a delay.  */
2262       if ((ip->insn_mo->pinfo & INSN_READ_FPR_S)
2263           && ((EXTRACT_OPERAND (FS, *ip) & ~(unsigned) 1)
2264               == (reg &~ (unsigned) 1)))
2265         return 1;
2266       if ((ip->insn_mo->pinfo & INSN_READ_FPR_T)
2267           && ((EXTRACT_OPERAND (FT, *ip) & ~(unsigned) 1)
2268               == (reg &~ (unsigned) 1)))
2269         return 1;
2270     }
2271   else if (! mips_opts.mips16)
2272     {
2273       if ((ip->insn_mo->pinfo & INSN_READ_GPR_S)
2274           && EXTRACT_OPERAND (RS, *ip) == reg)
2275         return 1;
2276       if ((ip->insn_mo->pinfo & INSN_READ_GPR_T)
2277           && EXTRACT_OPERAND (RT, *ip) == reg)
2278         return 1;
2279     }
2280   else
2281     {
2282       if ((ip->insn_mo->pinfo & MIPS16_INSN_READ_X)
2283           && mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RX, *ip)] == reg)
2284         return 1;
2285       if ((ip->insn_mo->pinfo & MIPS16_INSN_READ_Y)
2286           && mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RY, *ip)] == reg)
2287         return 1;
2288       if ((ip->insn_mo->pinfo & MIPS16_INSN_READ_Z)
2289           && (mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (MOVE32Z, *ip)]
2290               == reg))
2291         return 1;
2292       if ((ip->insn_mo->pinfo & MIPS16_INSN_READ_T) && reg == TREG)
2293         return 1;
2294       if ((ip->insn_mo->pinfo & MIPS16_INSN_READ_SP) && reg == SP)
2295         return 1;
2296       if ((ip->insn_mo->pinfo & MIPS16_INSN_READ_31) && reg == RA)
2297         return 1;
2298       if ((ip->insn_mo->pinfo & MIPS16_INSN_READ_GPR_X)
2299           && MIPS16_EXTRACT_OPERAND (REGR32, *ip) == reg)
2300         return 1;
2301     }
2302
2303   return 0;
2304 }
2305
2306 /* This function returns true if modifying a register requires a
2307    delay.  */
2308
2309 static int
2310 reg_needs_delay (unsigned int reg)
2311 {
2312   unsigned long prev_pinfo;
2313
2314   prev_pinfo = history[0].insn_mo->pinfo;
2315   if (! mips_opts.noreorder
2316       && (((prev_pinfo & INSN_LOAD_MEMORY_DELAY)
2317            && ! gpr_interlocks)
2318           || ((prev_pinfo & INSN_LOAD_COPROC_DELAY)
2319               && ! cop_interlocks)))
2320     {
2321       /* A load from a coprocessor or from memory.  All load delays
2322          delay the use of general register rt for one instruction.  */
2323       /* Itbl support may require additional care here.  */
2324       know (prev_pinfo & INSN_WRITE_GPR_T);
2325       if (reg == EXTRACT_OPERAND (RT, history[0]))
2326         return 1;
2327     }
2328
2329   return 0;
2330 }
2331
2332 /* Move all labels in insn_labels to the current insertion point.  */
2333
2334 static void
2335 mips_move_labels (void)
2336 {
2337   segment_info_type *si = seg_info (now_seg);
2338   struct insn_label_list *l;
2339   valueT val;
2340
2341   for (l = si->label_list; l != NULL; l = l->next)
2342     {
2343       gas_assert (S_GET_SEGMENT (l->label) == now_seg);
2344       symbol_set_frag (l->label, frag_now);
2345       val = (valueT) frag_now_fix ();
2346       /* mips16 text labels are stored as odd.  */
2347       if (mips_opts.mips16)
2348         ++val;
2349       S_SET_VALUE (l->label, val);
2350     }
2351 }
2352
2353 static bfd_boolean
2354 s_is_linkonce (symbolS *sym, segT from_seg)
2355 {
2356   bfd_boolean linkonce = FALSE;
2357   segT symseg = S_GET_SEGMENT (sym);
2358
2359   if (symseg != from_seg && !S_IS_LOCAL (sym))
2360     {
2361       if ((bfd_get_section_flags (stdoutput, symseg) & SEC_LINK_ONCE))
2362         linkonce = TRUE;
2363 #ifdef OBJ_ELF
2364       /* The GNU toolchain uses an extension for ELF: a section
2365          beginning with the magic string .gnu.linkonce is a
2366          linkonce section.  */
2367       if (strncmp (segment_name (symseg), ".gnu.linkonce",
2368                    sizeof ".gnu.linkonce" - 1) == 0)
2369         linkonce = TRUE;
2370 #endif
2371     }
2372   return linkonce;
2373 }
2374
2375 /* Mark instruction labels in mips16 mode.  This permits the linker to
2376    handle them specially, such as generating jalx instructions when
2377    needed.  We also make them odd for the duration of the assembly, in
2378    order to generate the right sort of code.  We will make them even
2379    in the adjust_symtab routine, while leaving them marked.  This is
2380    convenient for the debugger and the disassembler.  The linker knows
2381    to make them odd again.  */
2382
2383 static void
2384 mips16_mark_labels (void)
2385 {
2386   segment_info_type *si = seg_info (now_seg);
2387   struct insn_label_list *l;
2388
2389   if (!mips_opts.mips16)
2390     return;
2391
2392   for (l = si->label_list; l != NULL; l = l->next)
2393    {
2394       symbolS *label = l->label;
2395
2396 #if defined(OBJ_ELF) || defined(OBJ_MAYBE_ELF)
2397       if (IS_ELF)
2398         S_SET_OTHER (label, ELF_ST_SET_MIPS16 (S_GET_OTHER (label)));
2399 #endif
2400       if ((S_GET_VALUE (label) & 1) == 0
2401         /* Don't adjust the address if the label is global or weak, or
2402            in a link-once section, since we'll be emitting symbol reloc
2403            references to it which will be patched up by the linker, and
2404            the final value of the symbol may or may not be MIPS16.  */
2405           && ! S_IS_WEAK (label)
2406           && ! S_IS_EXTERNAL (label)
2407           && ! s_is_linkonce (label, now_seg))
2408         S_SET_VALUE (label, S_GET_VALUE (label) | 1);
2409     }
2410 }
2411
2412 /* End the current frag.  Make it a variant frag and record the
2413    relaxation info.  */
2414
2415 static void
2416 relax_close_frag (void)
2417 {
2418   mips_macro_warning.first_frag = frag_now;
2419   frag_var (rs_machine_dependent, 0, 0,
2420             RELAX_ENCODE (mips_relax.sizes[0], mips_relax.sizes[1]),
2421             mips_relax.symbol, 0, (char *) mips_relax.first_fixup);
2422
2423   memset (&mips_relax.sizes, 0, sizeof (mips_relax.sizes));
2424   mips_relax.first_fixup = 0;
2425 }
2426
2427 /* Start a new relaxation sequence whose expansion depends on SYMBOL.
2428    See the comment above RELAX_ENCODE for more details.  */
2429
2430 static void
2431 relax_start (symbolS *symbol)
2432 {
2433   gas_assert (mips_relax.sequence == 0);
2434   mips_relax.sequence = 1;
2435   mips_relax.symbol = symbol;
2436 }
2437
2438 /* Start generating the second version of a relaxable sequence.
2439    See the comment above RELAX_ENCODE for more details.  */
2440
2441 static void
2442 relax_switch (void)
2443 {
2444   gas_assert (mips_relax.sequence == 1);
2445   mips_relax.sequence = 2;
2446 }
2447
2448 /* End the current relaxable sequence.  */
2449
2450 static void
2451 relax_end (void)
2452 {
2453   gas_assert (mips_relax.sequence == 2);
2454   relax_close_frag ();
2455   mips_relax.sequence = 0;
2456 }
2457
2458 /* Classify an instruction according to the FIX_VR4120_* enumeration.
2459    Return NUM_FIX_VR4120_CLASSES if the instruction isn't affected
2460    by VR4120 errata.  */
2461
2462 static unsigned int
2463 classify_vr4120_insn (const char *name)
2464 {
2465   if (strncmp (name, "macc", 4) == 0)
2466     return FIX_VR4120_MACC;
2467   if (strncmp (name, "dmacc", 5) == 0)
2468     return FIX_VR4120_DMACC;
2469   if (strncmp (name, "mult", 4) == 0)
2470     return FIX_VR4120_MULT;
2471   if (strncmp (name, "dmult", 5) == 0)
2472     return FIX_VR4120_DMULT;
2473   if (strstr (name, "div"))
2474     return FIX_VR4120_DIV;
2475   if (strcmp (name, "mtlo") == 0 || strcmp (name, "mthi") == 0)
2476     return FIX_VR4120_MTHILO;
2477   return NUM_FIX_VR4120_CLASSES;
2478 }
2479
2480 #define INSN_ERET  0x42000018
2481 #define INSN_DERET 0x4200001f
2482
2483 /* Return the number of instructions that must separate INSN1 and INSN2,
2484    where INSN1 is the earlier instruction.  Return the worst-case value
2485    for any INSN2 if INSN2 is null.  */
2486
2487 static unsigned int
2488 insns_between (const struct mips_cl_insn *insn1,
2489                const struct mips_cl_insn *insn2)
2490 {
2491   unsigned long pinfo1, pinfo2;
2492
2493   /* This function needs to know which pinfo flags are set for INSN2
2494      and which registers INSN2 uses.  The former is stored in PINFO2 and
2495      the latter is tested via INSN2_USES_REG.  If INSN2 is null, PINFO2
2496      will have every flag set and INSN2_USES_REG will always return true.  */
2497   pinfo1 = insn1->insn_mo->pinfo;
2498   pinfo2 = insn2 ? insn2->insn_mo->pinfo : ~0U;
2499
2500 #define INSN2_USES_REG(REG, CLASS) \
2501    (insn2 == NULL || insn_uses_reg (insn2, REG, CLASS))
2502
2503   /* For most targets, write-after-read dependencies on the HI and LO
2504      registers must be separated by at least two instructions.  */
2505   if (!hilo_interlocks)
2506     {
2507       if ((pinfo1 & INSN_READ_LO) && (pinfo2 & INSN_WRITE_LO))
2508         return 2;
2509       if ((pinfo1 & INSN_READ_HI) && (pinfo2 & INSN_WRITE_HI))
2510         return 2;
2511     }
2512
2513   /* If we're working around r7000 errata, there must be two instructions
2514      between an mfhi or mflo and any instruction that uses the result.  */
2515   if (mips_7000_hilo_fix
2516       && MF_HILO_INSN (pinfo1)
2517       && INSN2_USES_REG (EXTRACT_OPERAND (RD, *insn1), MIPS_GR_REG))
2518     return 2;
2519
2520   /* If we're working around 24K errata, one instruction is required
2521      if an ERET or DERET is followed by a branch instruction.  */
2522   if (mips_fix_24k)
2523     {
2524       if (insn1->insn_opcode == INSN_ERET
2525           || insn1->insn_opcode == INSN_DERET)
2526         {
2527           if (insn2 == NULL
2528               || insn2->insn_opcode == INSN_ERET
2529               || insn2->insn_opcode == INSN_DERET
2530               || (insn2->insn_mo->pinfo
2531                   & (INSN_UNCOND_BRANCH_DELAY
2532                      | INSN_COND_BRANCH_DELAY
2533                      | INSN_COND_BRANCH_LIKELY)) != 0)
2534             return 1;
2535         }
2536     }
2537
2538   /* If working around VR4120 errata, check for combinations that need
2539      a single intervening instruction.  */
2540   if (mips_fix_vr4120)
2541     {
2542       unsigned int class1, class2;
2543
2544       class1 = classify_vr4120_insn (insn1->insn_mo->name);
2545       if (class1 != NUM_FIX_VR4120_CLASSES && vr4120_conflicts[class1] != 0)
2546         {
2547           if (insn2 == NULL)
2548             return 1;
2549           class2 = classify_vr4120_insn (insn2->insn_mo->name);
2550           if (vr4120_conflicts[class1] & (1 << class2))
2551             return 1;
2552         }
2553     }
2554
2555   if (!mips_opts.mips16)
2556     {
2557       /* Check for GPR or coprocessor load delays.  All such delays
2558          are on the RT register.  */
2559       /* Itbl support may require additional care here.  */
2560       if ((!gpr_interlocks && (pinfo1 & INSN_LOAD_MEMORY_DELAY))
2561           || (!cop_interlocks && (pinfo1 & INSN_LOAD_COPROC_DELAY)))
2562         {
2563           know (pinfo1 & INSN_WRITE_GPR_T);
2564           if (INSN2_USES_REG (EXTRACT_OPERAND (RT, *insn1), MIPS_GR_REG))
2565             return 1;
2566         }
2567
2568       /* Check for generic coprocessor hazards.
2569
2570          This case is not handled very well.  There is no special
2571          knowledge of CP0 handling, and the coprocessors other than
2572          the floating point unit are not distinguished at all.  */
2573       /* Itbl support may require additional care here. FIXME!
2574          Need to modify this to include knowledge about
2575          user specified delays!  */
2576       else if ((!cop_interlocks && (pinfo1 & INSN_COPROC_MOVE_DELAY))
2577                || (!cop_mem_interlocks && (pinfo1 & INSN_COPROC_MEMORY_DELAY)))
2578         {
2579           /* Handle cases where INSN1 writes to a known general coprocessor
2580              register.  There must be a one instruction delay before INSN2
2581              if INSN2 reads that register, otherwise no delay is needed.  */
2582           if (pinfo1 & INSN_WRITE_FPR_T)
2583             {
2584               if (INSN2_USES_REG (EXTRACT_OPERAND (FT, *insn1), MIPS_FP_REG))
2585                 return 1;
2586             }
2587           else if (pinfo1 & INSN_WRITE_FPR_S)
2588             {
2589               if (INSN2_USES_REG (EXTRACT_OPERAND (FS, *insn1), MIPS_FP_REG))
2590                 return 1;
2591             }
2592           else
2593             {
2594               /* Read-after-write dependencies on the control registers
2595                  require a two-instruction gap.  */
2596               if ((pinfo1 & INSN_WRITE_COND_CODE)
2597                   && (pinfo2 & INSN_READ_COND_CODE))
2598                 return 2;
2599
2600               /* We don't know exactly what INSN1 does.  If INSN2 is
2601                  also a coprocessor instruction, assume there must be
2602                  a one instruction gap.  */
2603               if (pinfo2 & INSN_COP)
2604                 return 1;
2605             }
2606         }
2607
2608       /* Check for read-after-write dependencies on the coprocessor
2609          control registers in cases where INSN1 does not need a general
2610          coprocessor delay.  This means that INSN1 is a floating point
2611          comparison instruction.  */
2612       /* Itbl support may require additional care here.  */
2613       else if (!cop_interlocks
2614                && (pinfo1 & INSN_WRITE_COND_CODE)
2615                && (pinfo2 & INSN_READ_COND_CODE))
2616         return 1;
2617     }
2618
2619 #undef INSN2_USES_REG
2620
2621   return 0;
2622 }
2623
2624 /* Return the number of nops that would be needed to work around the
2625    VR4130 mflo/mfhi errata if instruction INSN immediately followed
2626    the MAX_VR4130_NOPS instructions described by HIST.  */
2627
2628 static int
2629 nops_for_vr4130 (const struct mips_cl_insn *hist,
2630                  const struct mips_cl_insn *insn)
2631 {
2632   int i, j, reg;
2633
2634   /* Check if the instruction writes to HI or LO.  MTHI and MTLO
2635      are not affected by the errata.  */
2636   if (insn != 0
2637       && ((insn->insn_mo->pinfo & (INSN_WRITE_HI | INSN_WRITE_LO)) == 0
2638           || strcmp (insn->insn_mo->name, "mtlo") == 0
2639           || strcmp (insn->insn_mo->name, "mthi") == 0))
2640     return 0;
2641
2642   /* Search for the first MFLO or MFHI.  */
2643   for (i = 0; i < MAX_VR4130_NOPS; i++)
2644     if (MF_HILO_INSN (hist[i].insn_mo->pinfo))
2645       {
2646         /* Extract the destination register.  */
2647         if (mips_opts.mips16)
2648           reg = mips16_to_32_reg_map[MIPS16_EXTRACT_OPERAND (RX, hist[i])];
2649         else
2650           reg = EXTRACT_OPERAND (RD, hist[i]);
2651
2652         /* No nops are needed if INSN reads that register.  */
2653         if (insn != NULL && insn_uses_reg (insn, reg, MIPS_GR_REG))
2654           return 0;
2655
2656         /* ...or if any of the intervening instructions do.  */
2657         for (j = 0; j < i; j++)
2658           if (insn_uses_reg (&hist[j], reg, MIPS_GR_REG))
2659             return 0;
2660
2661         return MAX_VR4130_NOPS - i;
2662       }
2663   return 0;
2664 }
2665
2666 /* Return the number of nops that would be needed if instruction INSN
2667    immediately followed the MAX_NOPS instructions given by HIST,
2668    where HIST[0] is the most recent instruction.  If INSN is null,
2669    return the worse-case number of nops for any instruction.  */
2670
2671 static int
2672 nops_for_insn (const struct mips_cl_insn *hist,
2673                const struct mips_cl_insn *insn)
2674 {
2675   int i, nops, tmp_nops;
2676
2677   nops = 0;
2678   for (i = 0; i < MAX_DELAY_NOPS; i++)
2679     {
2680       tmp_nops = insns_between (hist + i, insn) - i;
2681       if (tmp_nops > nops)
2682         nops = tmp_nops;
2683     }
2684
2685   if (mips_fix_vr4130)
2686     {
2687       tmp_nops = nops_for_vr4130 (hist, insn);
2688       if (tmp_nops > nops)
2689         nops = tmp_nops;
2690     }
2691
2692   return nops;
2693 }
2694
2695 /* The variable arguments provide NUM_INSNS extra instructions that
2696    might be added to HIST.  Return the largest number of nops that
2697    would be needed after the extended sequence.  */
2698
2699 static int
2700 nops_for_sequence (int num_insns, const struct mips_cl_insn *hist, ...)
2701 {
2702   va_list args;
2703   struct mips_cl_insn buffer[MAX_NOPS];
2704   struct mips_cl_insn *cursor;
2705   int nops;
2706
2707   va_start (args, hist);
2708   cursor = buffer + num_insns;
2709   memcpy (cursor, hist, (MAX_NOPS - num_insns) * sizeof (*cursor));
2710   while (cursor > buffer)
2711     *--cursor = *va_arg (args, const struct mips_cl_insn *);
2712
2713   nops = nops_for_insn (buffer, NULL);
2714   va_end (args);
2715   return nops;
2716 }
2717
2718 /* Like nops_for_insn, but if INSN is a branch, take into account the
2719    worst-case delay for the branch target.  */
2720
2721 static int
2722 nops_for_insn_or_target (const struct mips_cl_insn *hist,
2723                          const struct mips_cl_insn *insn)
2724 {
2725   int nops, tmp_nops;
2726
2727   nops = nops_for_insn (hist, insn);
2728   if (insn->insn_mo->pinfo & (INSN_UNCOND_BRANCH_DELAY
2729                               | INSN_COND_BRANCH_DELAY
2730                               | INSN_COND_BRANCH_LIKELY))
2731     {
2732       tmp_nops = nops_for_sequence (2, hist, insn, NOP_INSN);
2733       if (tmp_nops > nops)
2734         nops = tmp_nops;
2735     }
2736   else if (mips_opts.mips16
2737            && (insn->insn_mo->pinfo & (MIPS16_INSN_UNCOND_BRANCH
2738                                        | MIPS16_INSN_COND_BRANCH)))
2739     {
2740       tmp_nops = nops_for_sequence (1, hist, insn);
2741       if (tmp_nops > nops)
2742         nops = tmp_nops;
2743     }
2744   return nops;
2745 }
2746
2747 /* Fix NOP issue: Replace nops by "or at,at,zero".  */
2748
2749 static void
2750 fix_loongson2f_nop (struct mips_cl_insn * ip)
2751 {
2752   if (strcmp (ip->insn_mo->name, "nop") == 0)
2753     ip->insn_opcode = LOONGSON2F_NOP_INSN;
2754 }
2755
2756 /* Fix Jump Issue: Eliminate instruction fetch from outside 256M region
2757                    jr target pc &= 'hffff_ffff_cfff_ffff.  */
2758
2759 static void
2760 fix_loongson2f_jump (struct mips_cl_insn * ip)
2761 {
2762   if (strcmp (ip->insn_mo->name, "j") == 0
2763       || strcmp (ip->insn_mo->name, "jr") == 0
2764       || strcmp (ip->insn_mo->name, "jalr") == 0)
2765     {
2766       int sreg;
2767       expressionS ep;
2768
2769       if (! mips_opts.at)
2770         return;
2771
2772       sreg = EXTRACT_OPERAND (RS, *ip);
2773       if (sreg == ZERO || sreg == KT0 || sreg == KT1 || sreg == ATREG)
2774         return;
2775
2776       ep.X_op = O_constant;
2777       ep.X_add_number = 0xcfff0000;
2778       macro_build (&ep, "lui", "t,u", ATREG, BFD_RELOC_HI16);
2779       ep.X_add_number = 0xffff;
2780       macro_build (&ep, "ori", "t,r,i", ATREG, ATREG, BFD_RELOC_LO16);
2781       macro_build (NULL, "and", "d,v,t", sreg, sreg, ATREG);
2782     }
2783 }
2784
2785 static void
2786 fix_loongson2f (struct mips_cl_insn * ip)
2787 {
2788   if (mips_fix_loongson2f_nop)
2789     fix_loongson2f_nop (ip);
2790
2791   if (mips_fix_loongson2f_jump)
2792     fix_loongson2f_jump (ip);
2793 }
2794
2795 /* Output an instruction.  IP is the instruction information.
2796    ADDRESS_EXPR is an operand of the instruction to be used with
2797    RELOC_TYPE.  */
2798
2799 static void
2800 append_insn (struct mips_cl_insn *ip, expressionS *address_expr,
2801              bfd_reloc_code_real_type *reloc_type)
2802 {
2803   unsigned long prev_pinfo, pinfo;
2804   relax_stateT prev_insn_frag_type = 0;
2805   bfd_boolean relaxed_branch = FALSE;
2806   segment_info_type *si = seg_info (now_seg);
2807
2808   if (mips_fix_loongson2f)
2809     fix_loongson2f (ip);
2810
2811   /* Mark instruction labels in mips16 mode.  */
2812   mips16_mark_labels ();
2813
2814   prev_pinfo = history[0].insn_mo->pinfo;
2815   pinfo = ip->insn_mo->pinfo;
2816
2817   if (mips_relax.sequence != 2 && !mips_opts.noreorder)
2818     {
2819       /* There are a lot of optimizations we could do that we don't.
2820          In particular, we do not, in general, reorder instructions.
2821          If you use gcc with optimization, it will reorder
2822          instructions and generally do much more optimization then we
2823          do here; repeating all that work in the assembler would only
2824          benefit hand written assembly code, and does not seem worth
2825          it.  */
2826       int nops = (mips_optimize == 0
2827                   ? nops_for_insn (history, NULL)
2828                   : nops_for_insn_or_target (history, ip));
2829       if (nops > 0)
2830         {
2831           fragS *old_frag;
2832           unsigned long old_frag_offset;
2833           int i;
2834
2835           old_frag = frag_now;
2836           old_frag_offset = frag_now_fix ();
2837
2838           for (i = 0; i < nops; i++)
2839             emit_nop ();
2840
2841           if (listing)
2842             {
2843               listing_prev_line ();
2844               /* We may be at the start of a variant frag.  In case we
2845                  are, make sure there is enough space for the frag
2846                  after the frags created by listing_prev_line.  The
2847                  argument to frag_grow here must be at least as large
2848                  as the argument to all other calls to frag_grow in
2849                  this file.  We don't have to worry about being in the
2850                  middle of a variant frag, because the variants insert
2851                  all needed nop instructions themselves.  */
2852               frag_grow (40);
2853             }
2854
2855           mips_move_labels ();
2856
2857 #ifndef NO_ECOFF_DEBUGGING
2858           if (ECOFF_DEBUGGING)
2859             ecoff_fix_loc (old_frag, old_frag_offset);
2860 #endif
2861         }
2862     }
2863   else if (mips_relax.sequence != 2 && prev_nop_frag != NULL)
2864     {
2865       /* Work out how many nops in prev_nop_frag are needed by IP.  */
2866       int nops = nops_for_insn_or_target (history, ip);
2867       gas_assert (nops <= prev_nop_frag_holds);
2868
2869       /* Enforce NOPS as a minimum.  */
2870       if (nops > prev_nop_frag_required)
2871         prev_nop_frag_required = nops;
2872
2873       if (prev_nop_frag_holds == prev_nop_frag_required)
2874         {
2875           /* Settle for the current number of nops.  Update the history
2876              accordingly (for the benefit of any future .set reorder code).  */
2877           prev_nop_frag = NULL;
2878           insert_into_history (prev_nop_frag_since,
2879                                prev_nop_frag_holds, NOP_INSN);
2880         }
2881       else
2882         {
2883           /* Allow this instruction to replace one of the nops that was
2884              tentatively added to prev_nop_frag.  */
2885           prev_nop_frag->fr_fix -= mips_opts.mips16 ? 2 : 4;
2886           prev_nop_frag_holds--;
2887           prev_nop_frag_since++;
2888         }
2889     }
2890
2891 #ifdef OBJ_ELF
2892   /* The value passed to dwarf2_emit_insn is the distance between
2893      the beginning of the current instruction and the address that
2894      should be recorded in the debug tables.  For MIPS16 debug info
2895      we want to use ISA-encoded addresses, so we pass -1 for an
2896      address higher by one than the current.  */
2897   dwarf2_emit_insn (mips_opts.mips16 ? -1 : 0);
2898 #endif
2899
2900   /* Record the frag type before frag_var.  */
2901   if (history[0].frag)
2902     prev_insn_frag_type = history[0].frag->fr_type;
2903
2904   if (address_expr
2905       && *reloc_type == BFD_RELOC_16_PCREL_S2
2906       && (pinfo & INSN_UNCOND_BRANCH_DELAY || pinfo & INSN_COND_BRANCH_DELAY
2907           || pinfo & INSN_COND_BRANCH_LIKELY)
2908       && mips_relax_branch
2909       /* Don't try branch relaxation within .set nomacro, or within
2910          .set noat if we use $at for PIC computations.  If it turns
2911          out that the branch was out-of-range, we'll get an error.  */
2912       && !mips_opts.warn_about_macros
2913       && (mips_opts.at || mips_pic == NO_PIC)
2914       && !mips_opts.mips16)
2915     {
2916       relaxed_branch = TRUE;
2917       add_relaxed_insn (ip, (relaxed_branch_length
2918                              (NULL, NULL,
2919                               (pinfo & INSN_UNCOND_BRANCH_DELAY) ? -1
2920                               : (pinfo & INSN_COND_BRANCH_LIKELY) ? 1
2921                               : 0)), 4,
2922                         RELAX_BRANCH_ENCODE
2923                         (pinfo & INSN_UNCOND_BRANCH_DELAY,
2924                          pinfo & INSN_COND_BRANCH_LIKELY,
2925                          pinfo & INSN_WRITE_GPR_31,
2926                          0),
2927                         address_expr->X_add_symbol,
2928                         address_expr->X_add_number);
2929       *reloc_type = BFD_RELOC_UNUSED;
2930     }
2931   else if (*reloc_type > BFD_RELOC_UNUSED)
2932     {
2933       /* We need to set up a variant frag.  */
2934       gas_assert (mips_opts.mips16 && address_expr != NULL);
2935       add_relaxed_insn (ip, 4, 0,
2936                         RELAX_MIPS16_ENCODE
2937                         (*reloc_type - BFD_RELOC_UNUSED,
2938                          mips16_small, mips16_ext,
2939                          prev_pinfo & INSN_UNCOND_BRANCH_DELAY,
2940                          history[0].mips16_absolute_jump_p),
2941                         make_expr_symbol (address_expr), 0);
2942     }
2943   else if (mips_opts.mips16
2944            && ! ip->use_extend
2945            && *reloc_type != BFD_RELOC_MIPS16_JMP)
2946     {
2947       if ((pinfo & INSN_UNCOND_BRANCH_DELAY) == 0)
2948         /* Make sure there is enough room to swap this instruction with
2949            a following jump instruction.  */
2950         frag_grow (6);
2951       add_fixed_insn (ip);
2952     }
2953   else
2954     {
2955       if (mips_opts.mips16
2956           && mips_opts.noreorder
2957           && (prev_pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
2958         as_warn (_("extended instruction in delay slot"));
2959
2960       if (mips_relax.sequence)
2961         {
2962           /* If we've reached the end of this frag, turn it into a variant
2963              frag and record the information for the instructions we've
2964              written so far.  */
2965           if (frag_room () < 4)
2966             relax_close_frag ();
2967           mips_relax.sizes[mips_relax.sequence - 1] += 4;
2968         }
2969
2970       if (mips_relax.sequence != 2)
2971         mips_macro_warning.sizes[0] += 4;
2972       if (mips_relax.sequence != 1)
2973         mips_macro_warning.sizes[1] += 4;
2974
2975       if (mips_opts.mips16)
2976         {
2977           ip->fixed_p = 1;
2978           ip->mips16_absolute_jump_p = (*reloc_type == BFD_RELOC_MIPS16_JMP);
2979         }
2980       add_fixed_insn (ip);
2981     }
2982
2983   if (address_expr != NULL && *reloc_type <= BFD_RELOC_UNUSED)
2984     {
2985       if (address_expr->X_op == O_constant)
2986         {
2987           unsigned int tmp;
2988
2989           switch (*reloc_type)
2990             {
2991             case BFD_RELOC_32:
2992               ip->insn_opcode |= address_expr->X_add_number;
2993               break;
2994
2995             case BFD_RELOC_MIPS_HIGHEST:
2996               tmp = (address_expr->X_add_number + 0x800080008000ull) >> 48;
2997               ip->insn_opcode |= tmp & 0xffff;
2998               break;
2999
3000             case BFD_RELOC_MIPS_HIGHER:
3001               tmp = (address_expr->X_add_number + 0x80008000ull) >> 32;
3002               ip->insn_opcode |= tmp & 0xffff;
3003               break;
3004
3005             case BFD_RELOC_HI16_S:
3006               tmp = (address_expr->X_add_number + 0x8000) >> 16;
3007               ip->insn_opcode |= tmp & 0xffff;
3008               break;
3009
3010             case BFD_RELOC_HI16:
3011               ip->insn_opcode |= (address_expr->X_add_number >> 16) & 0xffff;
3012               break;
3013
3014             case BFD_RELOC_UNUSED:
3015             case BFD_RELOC_LO16:
3016             case BFD_RELOC_MIPS_GOT_DISP:
3017               ip->insn_opcode |= address_expr->X_add_number & 0xffff;
3018               break;
3019
3020             case BFD_RELOC_MIPS_JMP:
3021               if ((address_expr->X_add_number & 3) != 0)
3022                 as_bad (_("jump to misaligned address (0x%lx)"),
3023                         (unsigned long) address_expr->X_add_number);
3024               ip->insn_opcode |= (address_expr->X_add_number >> 2) & 0x3ffffff;
3025               break;
3026
3027             case BFD_RELOC_MIPS16_JMP:
3028               if ((address_expr->X_add_number & 3) != 0)
3029                 as_bad (_("jump to misaligned address (0x%lx)"),
3030                         (unsigned long) address_expr->X_add_number);
3031               ip->insn_opcode |=
3032                 (((address_expr->X_add_number & 0x7c0000) << 3)
3033                  | ((address_expr->X_add_number & 0xf800000) >> 7)
3034                  | ((address_expr->X_add_number & 0x3fffc) >> 2));
3035               break;
3036
3037             case BFD_RELOC_16_PCREL_S2:
3038               if ((address_expr->X_add_number & 3) != 0)
3039                 as_bad (_("branch to misaligned address (0x%lx)"),
3040                         (unsigned long) address_expr->X_add_number);
3041               if (mips_relax_branch)
3042                 goto need_reloc;
3043               if ((address_expr->X_add_number + 0x20000) & ~0x3ffff)
3044                 as_bad (_("branch address range overflow (0x%lx)"),
3045                         (unsigned long) address_expr->X_add_number);
3046               ip->insn_opcode |= (address_expr->X_add_number >> 2) & 0xffff;
3047               break;
3048
3049             default:
3050               internalError ();
3051             }
3052         }
3053       else if (*reloc_type < BFD_RELOC_UNUSED)
3054         need_reloc:
3055         {
3056           reloc_howto_type *howto;
3057           int i;
3058
3059           /* In a compound relocation, it is the final (outermost)
3060              operator that determines the relocated field.  */
3061           for (i = 1; i < 3; i++)
3062             if (reloc_type[i] == BFD_RELOC_UNUSED)
3063               break;
3064
3065           howto = bfd_reloc_type_lookup (stdoutput, reloc_type[i - 1]);
3066           if (howto == NULL)
3067             {
3068               /* To reproduce this failure try assembling gas/testsuites/
3069                  gas/mips/mips16-intermix.s with a mips-ecoff targeted
3070                  assembler.  */
3071               as_bad (_("Unsupported MIPS relocation number %d"), reloc_type[i - 1]);
3072               howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_16);
3073             }
3074           
3075           ip->fixp[0] = fix_new_exp (ip->frag, ip->where,
3076                                      bfd_get_reloc_size (howto),
3077                                      address_expr,
3078                                      reloc_type[0] == BFD_RELOC_16_PCREL_S2,
3079                                      reloc_type[0]);
3080
3081           /* Tag symbols that have a R_MIPS16_26 relocation against them.  */
3082           if (reloc_type[0] == BFD_RELOC_MIPS16_JMP
3083               && ip->fixp[0]->fx_addsy)
3084             *symbol_get_tc (ip->fixp[0]->fx_addsy) = 1;
3085
3086           /* These relocations can have an addend that won't fit in
3087              4 octets for 64bit assembly.  */
3088           if (HAVE_64BIT_GPRS
3089               && ! howto->partial_inplace
3090               && (reloc_type[0] == BFD_RELOC_16
3091                   || reloc_type[0] == BFD_RELOC_32
3092                   || reloc_type[0] == BFD_RELOC_MIPS_JMP
3093                   || reloc_type[0] == BFD_RELOC_GPREL16
3094                   || reloc_type[0] == BFD_RELOC_MIPS_LITERAL
3095                   || reloc_type[0] == BFD_RELOC_GPREL32
3096                   || reloc_type[0] == BFD_RELOC_64
3097                   || reloc_type[0] == BFD_RELOC_CTOR
3098                   || reloc_type[0] == BFD_RELOC_MIPS_SUB
3099                   || reloc_type[0] == BFD_RELOC_MIPS_HIGHEST
3100                   || reloc_type[0] == BFD_RELOC_MIPS_HIGHER
3101                   || reloc_type[0] == BFD_RELOC_MIPS_SCN_DISP
3102                   || reloc_type[0] == BFD_RELOC_MIPS_REL16
3103                   || reloc_type[0] == BFD_RELOC_MIPS_RELGOT
3104                   || reloc_type[0] == BFD_RELOC_MIPS16_GPREL
3105                   || hi16_reloc_p (reloc_type[0])
3106                   || lo16_reloc_p (reloc_type[0])))
3107             ip->fixp[0]->fx_no_overflow = 1;
3108
3109           if (mips_relax.sequence)
3110             {
3111               if (mips_relax.first_fixup == 0)
3112                 mips_relax.first_fixup = ip->fixp[0];
3113             }
3114           else if (reloc_needs_lo_p (*reloc_type))
3115             {
3116               struct mips_hi_fixup *hi_fixup;
3117
3118               /* Reuse the last entry if it already has a matching %lo.  */
3119               hi_fixup = mips_hi_fixup_list;
3120               if (hi_fixup == 0
3121                   || !fixup_has_matching_lo_p (hi_fixup->fixp))
3122                 {
3123                   hi_fixup = ((struct mips_hi_fixup *)
3124                               xmalloc (sizeof (struct mips_hi_fixup)));
3125                   hi_fixup->next = mips_hi_fixup_list;
3126                   mips_hi_fixup_list = hi_fixup;
3127                 }
3128               hi_fixup->fixp = ip->fixp[0];
3129               hi_fixup->seg = now_seg;
3130             }
3131
3132           /* Add fixups for the second and third relocations, if given.
3133              Note that the ABI allows the second relocation to be
3134              against RSS_UNDEF, RSS_GP, RSS_GP0 or RSS_LOC.  At the
3135              moment we only use RSS_UNDEF, but we could add support
3136              for the others if it ever becomes necessary.  */
3137           for (i = 1; i < 3; i++)
3138             if (reloc_type[i] != BFD_RELOC_UNUSED)
3139               {
3140                 ip->fixp[i] = fix_new (ip->frag, ip->where,
3141                                        ip->fixp[0]->fx_size, NULL, 0,
3142                                        FALSE, reloc_type[i]);
3143
3144                 /* Use fx_tcbit to mark compound relocs.  */
3145                 ip->fixp[0]->fx_tcbit = 1;
3146                 ip->fixp[i]->fx_tcbit = 1;
3147               }
3148         }
3149     }
3150   install_insn (ip);
3151
3152   /* Update the register mask information.  */
3153   if (! mips_opts.mips16)
3154     {
3155       if (pinfo & INSN_WRITE_GPR_D)
3156         mips_gprmask |= 1 << EXTRACT_OPERAND (RD, *ip);
3157       if ((pinfo & (INSN_WRITE_GPR_T | INSN_READ_GPR_T)) != 0)
3158         mips_gprmask |= 1 << EXTRACT_OPERAND (RT, *ip);
3159       if (pinfo & INSN_READ_GPR_S)
3160         mips_gprmask |= 1 << EXTRACT_OPERAND (RS, *ip);
3161       if (pinfo & INSN_WRITE_GPR_31)
3162         mips_gprmask |= 1 << RA;
3163       if (pinfo & INSN_WRITE_FPR_D)
3164         mips_cprmask[1] |= 1 << EXTRACT_OPERAND (FD, *ip);
3165       if ((pinfo & (INSN_WRITE_FPR_S | INSN_READ_FPR_S)) != 0)
3166         mips_cprmask[1] |= 1 << EXTRACT_OPERAND (FS, *ip);
3167       if ((pinfo & (INSN_WRITE_FPR_T | INSN_READ_FPR_T)) != 0)
3168         mips_cprmask[1] |= 1 << EXTRACT_OPERAND (FT, *ip);
3169       if ((pinfo & INSN_READ_FPR_R) != 0)
3170         mips_cprmask[1] |= 1 << EXTRACT_OPERAND (FR, *ip);
3171       if (pinfo & INSN_COP)
3172         {
3173           /* We don't keep enough information to sort these cases out.
3174              The itbl support does keep this information however, although
3175              we currently don't support itbl fprmats as part of the cop
3176              instruction.  May want to add this support in the future.  */
3177         }
3178       /* Never set the bit for $0, which is always zero.  */
3179       mips_gprmask &= ~1 << 0;
3180     }
3181   else
3182     {
3183       if (pinfo & (MIPS16_INSN_WRITE_X | MIPS16_INSN_READ_X))
3184         mips_gprmask |= 1 << MIPS16_EXTRACT_OPERAND (RX, *ip);
3185       if (pinfo & (MIPS16_INSN_WRITE_Y | MIPS16_INSN_READ_Y))
3186         mips_gprmask |= 1 << MIPS16_EXTRACT_OPERAND (RY, *ip);
3187       if (pinfo & MIPS16_INSN_WRITE_Z)
3188         mips_gprmask |= 1 << MIPS16_EXTRACT_OPERAND (RZ, *ip);
3189       if (pinfo & (MIPS16_INSN_WRITE_T | MIPS16_INSN_READ_T))
3190         mips_gprmask |= 1 << TREG;
3191       if (pinfo & (MIPS16_INSN_WRITE_SP | MIPS16_INSN_READ_SP))
3192         mips_gprmask |= 1 << SP;
3193       if (pinfo & (MIPS16_INSN_WRITE_31 | MIPS16_INSN_READ_31))
3194         mips_gprmask |= 1 << RA;
3195       if (pinfo & MIPS16_INSN_WRITE_GPR_Y)
3196         mips_gprmask |= 1 << MIPS16OP_EXTRACT_REG32R (ip->insn_opcode);
3197       if (pinfo & MIPS16_INSN_READ_Z)
3198         mips_gprmask |= 1 << MIPS16_EXTRACT_OPERAND (MOVE32Z, *ip);
3199       if (pinfo & MIPS16_INSN_READ_GPR_X)
3200         mips_gprmask |= 1 << MIPS16_EXTRACT_OPERAND (REGR32, *ip);
3201     }
3202
3203   if (mips_relax.sequence != 2 && !mips_opts.noreorder)
3204     {
3205       /* Filling the branch delay slot is more complex.  We try to
3206          switch the branch with the previous instruction, which we can
3207          do if the previous instruction does not set up a condition
3208          that the branch tests and if the branch is not itself the
3209          target of any branch.  */
3210       if ((pinfo & INSN_UNCOND_BRANCH_DELAY)
3211           || (pinfo & INSN_COND_BRANCH_DELAY))
3212         {
3213           if (mips_optimize < 2
3214               /* If we have seen .set volatile or .set nomove, don't
3215                  optimize.  */
3216               || mips_opts.nomove != 0
3217               /* We can't swap if the previous instruction's position
3218                  is fixed.  */
3219               || history[0].fixed_p
3220               /* If the previous previous insn was in a .set
3221                  noreorder, we can't swap.  Actually, the MIPS
3222                  assembler will swap in this situation.  However, gcc
3223                  configured -with-gnu-as will generate code like
3224                    .set noreorder
3225                    lw   $4,XXX
3226                    .set reorder
3227                    INSN
3228                    bne  $4,$0,foo
3229                  in which we can not swap the bne and INSN.  If gcc is
3230                  not configured -with-gnu-as, it does not output the
3231                  .set pseudo-ops.  */
3232               || history[1].noreorder_p
3233               /* If the branch is itself the target of a branch, we
3234                  can not swap.  We cheat on this; all we check for is
3235                  whether there is a label on this instruction.  If
3236                  there are any branches to anything other than a
3237                  label, users must use .set noreorder.  */
3238               || si->label_list != NULL
3239               /* If the previous instruction is in a variant frag
3240                  other than this branch's one, we cannot do the swap.
3241                  This does not apply to the mips16, which uses variant
3242                  frags for different purposes.  */
3243               || (! mips_opts.mips16
3244                   && prev_insn_frag_type == rs_machine_dependent)
3245               /* Check for conflicts between the branch and the instructions
3246                  before the candidate delay slot.  */
3247               || nops_for_insn (history + 1, ip) > 0
3248               /* Check for conflicts between the swapped sequence and the
3249                  target of the branch.  */
3250               || nops_for_sequence (2, history + 1, ip, history) > 0
3251               /* We do not swap with a trap instruction, since it
3252                  complicates trap handlers to have the trap
3253                  instruction be in a delay slot.  */
3254               || (prev_pinfo & INSN_TRAP)
3255               /* If the branch reads a register that the previous
3256                  instruction sets, we can not swap.  */
3257               || (! mips_opts.mips16
3258                   && (prev_pinfo & INSN_WRITE_GPR_T)
3259                   && insn_uses_reg (ip, EXTRACT_OPERAND (RT, history[0]),
3260                                     MIPS_GR_REG))
3261               || (! mips_opts.mips16
3262                   && (prev_pinfo & INSN_WRITE_GPR_D)
3263                   && insn_uses_reg (ip, EXTRACT_OPERAND (RD, history[0]),
3264                                     MIPS_GR_REG))
3265               || (mips_opts.mips16
3266                   && (((prev_pinfo & MIPS16_INSN_WRITE_X)
3267                        && (insn_uses_reg
3268                            (ip, MIPS16_EXTRACT_OPERAND (RX, history[0]),
3269                             MIPS16_REG)))
3270                       || ((prev_pinfo & MIPS16_INSN_WRITE_Y)
3271                           && (insn_uses_reg
3272                               (ip, MIPS16_EXTRACT_OPERAND (RY, history[0]),
3273                                MIPS16_REG)))
3274                       || ((prev_pinfo & MIPS16_INSN_WRITE_Z)
3275                           && (insn_uses_reg
3276                               (ip, MIPS16_EXTRACT_OPERAND (RZ, history[0]),
3277                                MIPS16_REG)))
3278                       || ((prev_pinfo & MIPS16_INSN_WRITE_T)
3279                           && insn_uses_reg (ip, TREG, MIPS_GR_REG))
3280                       || ((prev_pinfo & MIPS16_INSN_WRITE_31)
3281                           && insn_uses_reg (ip, RA, MIPS_GR_REG))
3282                       || ((prev_pinfo & MIPS16_INSN_WRITE_GPR_Y)
3283                           && insn_uses_reg (ip,
3284                                             MIPS16OP_EXTRACT_REG32R
3285                                               (history[0].insn_opcode),
3286                                             MIPS_GR_REG))))
3287               /* If the branch writes a register that the previous
3288                  instruction sets, we can not swap (we know that
3289                  branches write only to RD or to $31).  */
3290               || (! mips_opts.mips16
3291                   && (prev_pinfo & INSN_WRITE_GPR_T)
3292                   && (((pinfo & INSN_WRITE_GPR_D)
3293                        && (EXTRACT_OPERAND (RT, history[0])
3294                            == EXTRACT_OPERAND (RD, *ip)))
3295                       || ((pinfo & INSN_WRITE_GPR_31)
3296                           && EXTRACT_OPERAND (RT, history[0]) == RA)))
3297               || (! mips_opts.mips16
3298                   && (prev_pinfo & INSN_WRITE_GPR_D)
3299                   && (((pinfo & INSN_WRITE_GPR_D)
3300                        && (EXTRACT_OPERAND (RD, history[0])
3301                            == EXTRACT_OPERAND (RD, *ip)))
3302                       || ((pinfo & INSN_WRITE_GPR_31)
3303                           && EXTRACT_OPERAND (RD, history[0]) == RA)))
3304               || (mips_opts.mips16
3305                   && (pinfo & MIPS16_INSN_WRITE_31)
3306                   && ((prev_pinfo & MIPS16_INSN_WRITE_31)
3307                       || ((prev_pinfo & MIPS16_INSN_WRITE_GPR_Y)
3308                           && (MIPS16OP_EXTRACT_REG32R (history[0].insn_opcode)
3309                               == RA))))
3310               /* If the branch writes a register that the previous
3311                  instruction reads, we can not swap (we know that
3312                  branches only write to RD or to $31).  */
3313               || (! mips_opts.mips16
3314                   && (pinfo & INSN_WRITE_GPR_D)
3315                   && insn_uses_reg (&history[0],
3316                                     EXTRACT_OPERAND (RD, *ip),
3317                                     MIPS_GR_REG))
3318               || (! mips_opts.mips16
3319                   && (pinfo & INSN_WRITE_GPR_31)
3320                   && insn_uses_reg (&history[0], RA, MIPS_GR_REG))
3321               || (mips_opts.mips16
3322                   && (pinfo & MIPS16_INSN_WRITE_31)
3323                   && insn_uses_reg (&history[0], RA, MIPS_GR_REG))
3324               /* If one instruction sets a condition code and the
3325                  other one uses a condition code, we can not swap.  */
3326               || ((pinfo & INSN_READ_COND_CODE)
3327                   && (prev_pinfo & INSN_WRITE_COND_CODE))
3328               || ((pinfo & INSN_WRITE_COND_CODE)
3329                   && (prev_pinfo & INSN_READ_COND_CODE))
3330               /* If the previous instruction uses the PC, we can not
3331                  swap.  */
3332               || (mips_opts.mips16
3333                   && (prev_pinfo & MIPS16_INSN_READ_PC))
3334               /* If the previous instruction had a fixup in mips16
3335                  mode, we can not swap.  This normally means that the
3336                  previous instruction was a 4 byte branch anyhow.  */
3337               || (mips_opts.mips16 && history[0].fixp[0])
3338               /* If the previous instruction is a sync, sync.l, or
3339                  sync.p, we can not swap.  */
3340               || (prev_pinfo & INSN_SYNC)
3341               /* If the previous instruction is an ERET or
3342                  DERET, avoid the swap.  */
3343               || (history[0].insn_opcode == INSN_ERET)
3344               || (history[0].insn_opcode == INSN_DERET))
3345             {
3346               if (mips_opts.mips16
3347                   && (pinfo & INSN_UNCOND_BRANCH_DELAY)
3348                   && (pinfo & (MIPS16_INSN_READ_X | MIPS16_INSN_READ_31))
3349                   && ISA_SUPPORTS_MIPS16E)
3350                 {
3351                   /* Convert MIPS16 jr/jalr into a "compact" jump.  */
3352                   ip->insn_opcode |= 0x0080;
3353                   install_insn (ip);
3354                   insert_into_history (0, 1, ip);
3355                 } 
3356               else
3357                 {
3358                   /* We could do even better for unconditional branches to
3359                      portions of this object file; we could pick up the
3360                      instruction at the destination, put it in the delay
3361                      slot, and bump the destination address.  */
3362                   insert_into_history (0, 1, ip);
3363                   emit_nop ();
3364                 }
3365                 
3366               if (mips_relax.sequence)
3367                 mips_relax.sizes[mips_relax.sequence - 1] += 4;
3368             }
3369           else
3370             {
3371               /* It looks like we can actually do the swap.  */
3372               struct mips_cl_insn delay = history[0];
3373               if (mips_opts.mips16)
3374                 {
3375                   know (delay.frag == ip->frag);
3376                   move_insn (ip, delay.frag, delay.where);
3377                   move_insn (&delay, ip->frag, ip->where + insn_length (ip));
3378                 }
3379               else if (relaxed_branch)
3380                 {
3381                   /* Add the delay slot instruction to the end of the
3382                      current frag and shrink the fixed part of the
3383                      original frag.  If the branch occupies the tail of
3384                      the latter, move it backwards to cover the gap.  */
3385                   delay.frag->fr_fix -= 4;
3386                   if (delay.frag == ip->frag)
3387                     move_insn (ip, ip->frag, ip->where - 4);
3388                   add_fixed_insn (&delay);
3389                 }
3390               else
3391                 {
3392                   move_insn (&delay, ip->frag, ip->where);
3393                   move_insn (ip, history[0].frag, history[0].where);
3394                 }
3395               history[0] = *ip;
3396               delay.fixed_p = 1;
3397               insert_into_history (0, 1, &delay);
3398             }
3399
3400           /* If that was an unconditional branch, forget the previous
3401              insn information.  */
3402           if (pinfo & INSN_UNCOND_BRANCH_DELAY)
3403             {
3404               mips_no_prev_insn ();
3405             }
3406         }
3407       else if (pinfo & INSN_COND_BRANCH_LIKELY)
3408         {
3409           /* We don't yet optimize a branch likely.  What we should do
3410              is look at the target, copy the instruction found there
3411              into the delay slot, and increment the branch to jump to
3412              the next instruction.  */
3413           insert_into_history (0, 1, ip);
3414           emit_nop ();
3415         }
3416       else
3417         insert_into_history (0, 1, ip);
3418     }
3419   else
3420     insert_into_history (0, 1, ip);
3421
3422   /* We just output an insn, so the next one doesn't have a label.  */
3423   mips_clear_insn_labels ();
3424 }
3425
3426 /* Forget that there was any previous instruction or label.  */
3427
3428 static void
3429 mips_no_prev_insn (void)
3430 {
3431   prev_nop_frag = NULL;
3432   insert_into_history (0, ARRAY_SIZE (history), NOP_INSN);
3433   mips_clear_insn_labels ();
3434 }
3435
3436 /* This function must be called before we emit something other than
3437    instructions.  It is like mips_no_prev_insn except that it inserts
3438    any NOPS that might be needed by previous instructions.  */
3439
3440 void
3441 mips_emit_delays (void)
3442 {
3443   if (! mips_opts.noreorder)
3444     {
3445       int nops = nops_for_insn (history, NULL);
3446       if (nops > 0)
3447         {
3448           while (nops-- > 0)
3449             add_fixed_insn (NOP_INSN);
3450           mips_move_labels ();
3451         }
3452     }
3453   mips_no_prev_insn ();
3454 }
3455
3456 /* Start a (possibly nested) noreorder block.  */
3457
3458 static void
3459 start_noreorder (void)
3460 {
3461   if (mips_opts.noreorder == 0)
3462     {
3463       unsigned int i;
3464       int nops;
3465
3466       /* None of the instructions before the .set noreorder can be moved.  */
3467       for (i = 0; i < ARRAY_SIZE (history); i++)
3468         history[i].fixed_p = 1;
3469
3470       /* Insert any nops that might be needed between the .set noreorder
3471          block and the previous instructions.  We will later remove any
3472          nops that turn out not to be needed.  */
3473       nops = nops_for_insn (history, NULL);
3474       if (nops > 0)
3475         {
3476           if (mips_optimize != 0)
3477             {
3478               /* Record the frag which holds the nop instructions, so
3479                  that we can remove them if we don't need them.  */
3480               frag_grow (mips_opts.mips16 ? nops * 2 : nops * 4);
3481               prev_nop_frag = frag_now;
3482               prev_nop_frag_holds = nops;
3483               prev_nop_frag_required = 0;
3484               prev_nop_frag_since = 0;
3485             }
3486
3487           for (; nops > 0; --nops)
3488             add_fixed_insn (NOP_INSN);
3489
3490           /* Move on to a new frag, so that it is safe to simply
3491              decrease the size of prev_nop_frag.  */
3492           frag_wane (frag_now);
3493           frag_new (0);
3494           mips_move_labels ();
3495         }
3496       mips16_mark_labels ();
3497       mips_clear_insn_labels ();
3498     }
3499   mips_opts.noreorder++;
3500   mips_any_noreorder = 1;
3501 }
3502
3503 /* End a nested noreorder block.  */
3504
3505 static void
3506 end_noreorder (void)
3507 {
3508
3509   mips_opts.noreorder--;
3510   if (mips_opts.noreorder == 0 && prev_nop_frag != NULL)
3511     {
3512       /* Commit to inserting prev_nop_frag_required nops and go back to
3513          handling nop insertion the .set reorder way.  */
3514       prev_nop_frag->fr_fix -= ((prev_nop_frag_holds - prev_nop_frag_required)
3515                                 * (mips_opts.mips16 ? 2 : 4));
3516       insert_into_history (prev_nop_frag_since,
3517                            prev_nop_frag_required, NOP_INSN);
3518       prev_nop_frag = NULL;
3519     }
3520 }
3521
3522 /* Set up global variables for the start of a new macro.  */
3523
3524 static void
3525 macro_start (void)
3526 {
3527   memset (&mips_macro_warning.sizes, 0, sizeof (mips_macro_warning.sizes));
3528   mips_macro_warning.delay_slot_p = (mips_opts.noreorder
3529                                      && (history[0].insn_mo->pinfo
3530                                          & (INSN_UNCOND_BRANCH_DELAY
3531                                             | INSN_COND_BRANCH_DELAY
3532                                             | INSN_COND_BRANCH_LIKELY)) != 0);
3533 }
3534
3535 /* Given that a macro is longer than 4 bytes, return the appropriate warning
3536    for it.  Return null if no warning is needed.  SUBTYPE is a bitmask of
3537    RELAX_DELAY_SLOT and RELAX_NOMACRO.  */
3538
3539 static const char *
3540 macro_warning (relax_substateT subtype)
3541 {
3542   if (subtype & RELAX_DELAY_SLOT)
3543     return _("Macro instruction expanded into multiple instructions"
3544              " in a branch delay slot");
3545   else if (subtype & RELAX_NOMACRO)
3546     return _("Macro instruction expanded into multiple instructions");
3547   else
3548     return 0;
3549 }
3550
3551 /* Finish up a macro.  Emit warnings as appropriate.  */
3552
3553 static void
3554 macro_end (void)
3555 {
3556   if (mips_macro_warning.sizes[0] > 4 || mips_macro_warning.sizes[1] > 4)
3557     {
3558       relax_substateT subtype;
3559
3560       /* Set up the relaxation warning flags.  */
3561       subtype = 0;
3562       if (mips_macro_warning.sizes[1] > mips_macro_warning.sizes[0])
3563         subtype |= RELAX_SECOND_LONGER;
3564       if (mips_opts.warn_about_macros)
3565         subtype |= RELAX_NOMACRO;
3566       if (mips_macro_warning.delay_slot_p)
3567         subtype |= RELAX_DELAY_SLOT;
3568
3569       if (mips_macro_warning.sizes[0] > 4 && mips_macro_warning.sizes[1] > 4)
3570         {
3571           /* Either the macro has a single implementation or both
3572              implementations are longer than 4 bytes.  Emit the
3573              warning now.  */
3574           const char *msg = macro_warning (subtype);
3575           if (msg != 0)
3576             as_warn ("%s", msg);
3577         }
3578       else
3579         {
3580           /* One implementation might need a warning but the other
3581              definitely doesn't.  */
3582           mips_macro_warning.first_frag->fr_subtype |= subtype;
3583         }
3584     }
3585 }
3586
3587 /* Read a macro's relocation codes from *ARGS and store them in *R.
3588    The first argument in *ARGS will be either the code for a single
3589    relocation or -1 followed by the three codes that make up a
3590    composite relocation.  */
3591
3592 static void
3593 macro_read_relocs (va_list *args, bfd_reloc_code_real_type *r)
3594 {
3595   int i, next;
3596
3597   next = va_arg (*args, int);
3598   if (next >= 0)
3599     r[0] = (bfd_reloc_code_real_type) next;
3600   else
3601     for (i = 0; i < 3; i++)
3602       r[i] = (bfd_reloc_code_real_type) va_arg (*args, int);
3603 }
3604
3605 /* Build an instruction created by a macro expansion.  This is passed
3606    a pointer to the count of instructions created so far, an
3607    expression, the name of the instruction to build, an operand format
3608    string, and corresponding arguments.  */
3609
3610 static void
3611 macro_build (expressionS *ep, const char *name, const char *fmt, ...)
3612 {
3613   const struct mips_opcode *mo;
3614   struct mips_cl_insn insn;
3615   bfd_reloc_code_real_type r[3];
3616   va_list args;
3617
3618   va_start (args, fmt);
3619
3620   if (mips_opts.mips16)
3621     {
3622       mips16_macro_build (ep, name, fmt, &args);
3623       va_end (args);
3624       return;
3625     }
3626
3627   r[0] = BFD_RELOC_UNUSED;
3628   r[1] = BFD_RELOC_UNUSED;
3629   r[2] = BFD_RELOC_UNUSED;
3630   mo = (struct mips_opcode *) hash_find (op_hash, name);
3631   gas_assert (mo);
3632   gas_assert (strcmp (name, mo->name) == 0);
3633
3634   while (1)
3635     {
3636       /* Search until we get a match for NAME.  It is assumed here that
3637          macros will never generate MDMX, MIPS-3D, or MT instructions.  */
3638       if (strcmp (fmt, mo->args) == 0
3639           && mo->pinfo != INSN_MACRO
3640           && is_opcode_valid (mo))
3641         break;
3642
3643       ++mo;
3644       gas_assert (mo->name);
3645       gas_assert (strcmp (name, mo->name) == 0);
3646     }
3647
3648   create_insn (&insn, mo);
3649   for (;;)
3650     {
3651       switch (*fmt++)
3652         {
3653         case '\0':
3654           break;
3655
3656         case ',':
3657         case '(':
3658         case ')':
3659           continue;
3660
3661         case '+':
3662           switch (*fmt++)
3663             {
3664             case 'A':
3665             case 'E':
3666               INSERT_OPERAND (SHAMT, insn, va_arg (args, int));
3667               continue;
3668
3669             case 'B':
3670             case 'F':
3671               /* Note that in the macro case, these arguments are already
3672                  in MSB form.  (When handling the instruction in the
3673                  non-macro case, these arguments are sizes from which
3674                  MSB values must be calculated.)  */
3675               INSERT_OPERAND (INSMSB, insn, va_arg (args, int));
3676               continue;
3677
3678             case 'C':
3679             case 'G':
3680             case 'H':
3681               /* Note that in the macro case, these arguments are already
3682                  in MSBD form.  (When handling the instruction in the
3683                  non-macro case, these arguments are sizes from which
3684                  MSBD values must be calculated.)  */
3685               INSERT_OPERAND (EXTMSBD, insn, va_arg (args, int));
3686               continue;
3687
3688             case 'Q':
3689               INSERT_OPERAND (SEQI, insn, va_arg (args, int));
3690               continue;
3691
3692             default:
3693               internalError ();
3694             }
3695           continue;
3696
3697         case '2':
3698           INSERT_OPERAND (BP, insn, va_arg (args, int));
3699           continue;
3700
3701         case 't':
3702         case 'w':
3703         case 'E':
3704           INSERT_OPERAND (RT, insn, va_arg (args, int));
3705           continue;
3706
3707         case 'c':
3708           INSERT_OPERAND (CODE, insn, va_arg (args, int));
3709           continue;
3710
3711         case 'T':
3712         case 'W':
3713           INSERT_OPERAND (FT, insn, va_arg (args, int));
3714           continue;
3715
3716         case 'd':
3717         case 'G':
3718         case 'K':
3719           INSERT_OPERAND (RD, insn, va_arg (args, int));
3720           continue;
3721
3722         case 'U':
3723           {
3724             int tmp = va_arg (args, int);
3725
3726             INSERT_OPERAND (RT, insn, tmp);
3727             INSERT_OPERAND (RD, insn, tmp);
3728             continue;
3729           }
3730
3731         case 'V':
3732         case 'S':
3733           INSERT_OPERAND (FS, insn, va_arg (args, int));
3734           continue;
3735
3736         case 'z':
3737           continue;
3738
3739         case '<':
3740           INSERT_OPERAND (SHAMT, insn, va_arg (args, int));
3741           continue;
3742
3743         case 'D':
3744           INSERT_OPERAND (FD, insn, va_arg (args, int));
3745           continue;
3746
3747         case 'B':
3748           INSERT_OPERAND (CODE20, insn, va_arg (args, int));
3749           continue;
3750
3751         case 'J':
3752           INSERT_OPERAND (CODE19, insn, va_arg (args, int));
3753           continue;
3754
3755         case 'q':
3756           INSERT_OPERAND (CODE2, insn, va_arg (args, int));
3757           continue;
3758
3759         case 'b':
3760         case 's':
3761         case 'r':
3762         case 'v':
3763           INSERT_OPERAND (RS, insn, va_arg (args, int));
3764           continue;
3765
3766         case 'i':
3767         case 'j':
3768           macro_read_relocs (&args, r);
3769           gas_assert (*r == BFD_RELOC_GPREL16
3770                       || *r == BFD_RELOC_MIPS_HIGHER
3771                       || *r == BFD_RELOC_HI16_S
3772                       || *r == BFD_RELOC_LO16
3773                       || *r == BFD_RELOC_MIPS_GOT_OFST);
3774           continue;
3775
3776         case 'o':
3777           macro_read_relocs (&args, r);
3778           continue;
3779
3780         case 'u':
3781           macro_read_relocs (&args, r);
3782           gas_assert (ep != NULL
3783                   && (ep->X_op == O_constant
3784                       || (ep->X_op == O_symbol
3785                           && (*r == BFD_RELOC_MIPS_HIGHEST
3786                               || *r == BFD_RELOC_HI16_S
3787                               || *r == BFD_RELOC_HI16
3788                               || *r == BFD_RELOC_GPREL16
3789                               || *r == BFD_RELOC_MIPS_GOT_HI16
3790                               || *r == BFD_RELOC_MIPS_CALL_HI16))));
3791           continue;
3792
3793         case 'p':
3794           gas_assert (ep != NULL);
3795
3796           /*
3797            * This allows macro() to pass an immediate expression for
3798            * creating short branches without creating a symbol.
3799            *
3800            * We don't allow branch relaxation for these branches, as
3801            * they should only appear in ".set nomacro" anyway.
3802            */
3803           if (ep->X_op == O_constant)
3804             {
3805               if ((ep->X_add_number & 3) != 0)
3806                 as_bad (_("branch to misaligned address (0x%lx)"),
3807                         (unsigned long) ep->X_add_number);
3808               if ((ep->X_add_number + 0x20000) & ~0x3ffff)
3809                 as_bad (_("branch address range overflow (0x%lx)"),
3810                         (unsigned long) ep->X_add_number);
3811               insn.insn_opcode |= (ep->X_add_number >> 2) & 0xffff;
3812               ep = NULL;
3813             }
3814           else
3815             *r = BFD_RELOC_16_PCREL_S2;
3816           continue;
3817
3818         case 'a':
3819           gas_assert (ep != NULL);
3820           *r = BFD_RELOC_MIPS_JMP;
3821           continue;
3822
3823         case 'C':
3824           INSERT_OPERAND (COPZ, insn, va_arg (args, unsigned long));
3825           continue;
3826
3827         case 'k':
3828           INSERT_OPERAND (CACHE, insn, va_arg (args, unsigned long));
3829           continue;
3830
3831         default:
3832           internalError ();
3833         }
3834       break;
3835     }
3836   va_end (args);
3837   gas_assert (*r == BFD_RELOC_UNUSED ? ep == NULL : ep != NULL);
3838
3839   append_insn (&insn, ep, r);
3840 }
3841
3842 static void
3843 mips16_macro_build (expressionS *ep, const char *name, const char *fmt,
3844                     va_list *args)
3845 {
3846   struct mips_opcode *mo;
3847   struct mips_cl_insn insn;
3848   bfd_reloc_code_real_type r[3]
3849     = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
3850
3851   mo = (struct mips_opcode *) hash_find (mips16_op_hash, name);
3852   gas_assert (mo);
3853   gas_assert (strcmp (name, mo->name) == 0);
3854
3855   while (strcmp (fmt, mo->args) != 0 || mo->pinfo == INSN_MACRO)
3856     {
3857       ++mo;
3858       gas_assert (mo->name);
3859       gas_assert (strcmp (name, mo->name) == 0);
3860     }
3861
3862   create_insn (&insn, mo);
3863   for (;;)
3864     {
3865       int c;
3866
3867       c = *fmt++;
3868       switch (c)
3869         {
3870         case '\0':
3871           break;
3872
3873         case ',':
3874         case '(':
3875         case ')':
3876           continue;
3877
3878         case 'y':
3879         case 'w':
3880           MIPS16_INSERT_OPERAND (RY, insn, va_arg (*args, int));
3881           continue;
3882
3883         case 'x':
3884         case 'v':
3885           MIPS16_INSERT_OPERAND (RX, insn, va_arg (*args, int));
3886           continue;
3887
3888         case 'z':
3889           MIPS16_INSERT_OPERAND (RZ, insn, va_arg (*args, int));
3890           continue;
3891
3892         case 'Z':
3893           MIPS16_INSERT_OPERAND (MOVE32Z, insn, va_arg (*args, int));
3894           continue;
3895
3896         case '0':
3897         case 'S':
3898         case 'P':
3899         case 'R':
3900           continue;
3901
3902         case 'X':
3903           MIPS16_INSERT_OPERAND (REGR32, insn, va_arg (*args, int));
3904           continue;
3905
3906         case 'Y':
3907           {
3908             int regno;
3909
3910             regno = va_arg (*args, int);
3911             regno = ((regno & 7) << 2) | ((regno & 0x18) >> 3);
3912             MIPS16_INSERT_OPERAND (REG32R, insn, regno);
3913           }
3914           continue;
3915
3916         case '<':
3917         case '>':
3918         case '4':
3919         case '5':
3920         case 'H':
3921         case 'W':
3922         case 'D':
3923         case 'j':
3924         case '8':
3925         case 'V':
3926         case 'C':
3927         case 'U':
3928         case 'k':
3929         case 'K':
3930         case 'p':
3931         case 'q':
3932           {
3933             gas_assert (ep != NULL);
3934
3935             if (ep->X_op != O_constant)
3936               *r = (int) BFD_RELOC_UNUSED + c;
3937             else
3938               {
3939                 mips16_immed (NULL, 0, c, ep->X_add_number, FALSE, FALSE,
3940                               FALSE, &insn.insn_opcode, &insn.use_extend,
3941                               &insn.extend);
3942                 ep = NULL;
3943                 *r = BFD_RELOC_UNUSED;
3944               }
3945           }
3946           continue;
3947
3948         case '6':
3949           MIPS16_INSERT_OPERAND (IMM6, insn, va_arg (*args, int));
3950           continue;
3951         }
3952
3953       break;
3954     }
3955
3956   gas_assert (*r == BFD_RELOC_UNUSED ? ep == NULL : ep != NULL);
3957
3958   append_insn (&insn, ep, r);
3959 }
3960
3961 /*
3962  * Sign-extend 32-bit mode constants that have bit 31 set and all
3963  * higher bits unset.
3964  */
3965 static void
3966 normalize_constant_expr (expressionS *ex)
3967 {
3968   if (ex->X_op == O_constant
3969       && IS_ZEXT_32BIT_NUM (ex->X_add_number))
3970     ex->X_add_number = (((ex->X_add_number & 0xffffffff) ^ 0x80000000)
3971                         - 0x80000000);
3972 }
3973
3974 /*
3975  * Sign-extend 32-bit mode address offsets that have bit 31 set and
3976  * all higher bits unset.
3977  */
3978 static void
3979 normalize_address_expr (expressionS *ex)
3980 {
3981   if (((ex->X_op == O_constant && HAVE_32BIT_ADDRESSES)
3982         || (ex->X_op == O_symbol && HAVE_32BIT_SYMBOLS))
3983       && IS_ZEXT_32BIT_NUM (ex->X_add_number))
3984     ex->X_add_number = (((ex->X_add_number & 0xffffffff) ^ 0x80000000)
3985                         - 0x80000000);
3986 }
3987
3988 /*
3989  * Generate a "jalr" instruction with a relocation hint to the called
3990  * function.  This occurs in NewABI PIC code.
3991  */
3992 static void
3993 macro_build_jalr (expressionS *ep)
3994 {
3995   char *f = NULL;
3996
3997   if (MIPS_JALR_HINT_P (ep))
3998     {
3999       frag_grow (8);
4000       f = frag_more (0);
4001     }
4002   macro_build (NULL, "jalr", "d,s", RA, PIC_CALL_REG);
4003   if (MIPS_JALR_HINT_P (ep))
4004     fix_new_exp (frag_now, f - frag_now->fr_literal,
4005                  4, ep, FALSE, BFD_RELOC_MIPS_JALR);
4006 }
4007
4008 /*
4009  * Generate a "lui" instruction.
4010  */
4011 static void
4012 macro_build_lui (expressionS *ep, int regnum)
4013 {
4014   expressionS high_expr;
4015   const struct mips_opcode *mo;
4016   struct mips_cl_insn insn;
4017   bfd_reloc_code_real_type r[3]
4018     = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED};
4019   const char *name = "lui";
4020   const char *fmt = "t,u";
4021
4022   gas_assert (! mips_opts.mips16);
4023
4024   high_expr = *ep;
4025
4026   if (high_expr.X_op == O_constant)
4027     {
4028       /* We can compute the instruction now without a relocation entry.  */
4029       high_expr.X_add_number = ((high_expr.X_add_number + 0x8000)
4030                                 >> 16) & 0xffff;
4031       *r = BFD_RELOC_UNUSED;
4032     }
4033   else
4034     {
4035       gas_assert (ep->X_op == O_symbol);
4036       /* _gp_disp is a special case, used from s_cpload.
4037          __gnu_local_gp is used if mips_no_shared.  */
4038       gas_assert (mips_pic == NO_PIC
4039               || (! HAVE_NEWABI
4040                   && strcmp (S_GET_NAME (ep->X_add_symbol), "_gp_disp") == 0)
4041               || (! mips_in_shared
4042                   && strcmp (S_GET_NAME (ep->X_add_symbol),
4043                              "__gnu_local_gp") == 0));
4044       *r = BFD_RELOC_HI16_S;
4045     }
4046
4047   mo = hash_find (op_hash, name);
4048   gas_assert (strcmp (name, mo->name) == 0);
4049   gas_assert (strcmp (fmt, mo->args) == 0);
4050   create_insn (&insn, mo);
4051
4052   insn.insn_opcode = insn.insn_mo->match;
4053   INSERT_OPERAND (RT, insn, regnum);
4054   if (*r == BFD_RELOC_UNUSED)
4055     {
4056       insn.insn_opcode |= high_expr.X_add_number;
4057       append_insn (&insn, NULL, r);
4058     }
4059   else
4060     append_insn (&insn, &high_expr, r);
4061 }
4062
4063 /* Generate a sequence of instructions to do a load or store from a constant
4064    offset off of a base register (breg) into/from a target register (treg),
4065    using AT if necessary.  */
4066 static void
4067 macro_build_ldst_constoffset (expressionS *ep, const char *op,
4068                               int treg, int breg, int dbl)
4069 {
4070   gas_assert (ep->X_op == O_constant);
4071
4072   /* Sign-extending 32-bit constants makes their handling easier.  */
4073   if (!dbl)
4074     normalize_constant_expr (ep);
4075
4076   /* Right now, this routine can only handle signed 32-bit constants.  */
4077   if (! IS_SEXT_32BIT_NUM(ep->X_add_number + 0x8000))
4078     as_warn (_("operand overflow"));
4079
4080   if (IS_SEXT_16BIT_NUM(ep->X_add_number))
4081     {
4082       /* Signed 16-bit offset will fit in the op.  Easy!  */
4083       macro_build (ep, op, "t,o(b)", treg, BFD_RELOC_LO16, breg);
4084     }
4085   else
4086     {
4087       /* 32-bit offset, need multiple instructions and AT, like:
4088            lui      $tempreg,const_hi       (BFD_RELOC_HI16_S)
4089            addu     $tempreg,$tempreg,$breg
4090            <op>     $treg,const_lo($tempreg)   (BFD_RELOC_LO16)
4091          to handle the complete offset.  */
4092       macro_build_lui (ep, AT);
4093       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, AT, breg);
4094       macro_build (ep, op, "t,o(b)", treg, BFD_RELOC_LO16, AT);
4095
4096       if (!mips_opts.at)
4097         as_bad (_("Macro used $at after \".set noat\""));
4098     }
4099 }
4100
4101 /*                      set_at()
4102  * Generates code to set the $at register to true (one)
4103  * if reg is less than the immediate expression.
4104  */
4105 static void
4106 set_at (int reg, int unsignedp)
4107 {
4108   if (imm_expr.X_op == O_constant
4109       && imm_expr.X_add_number >= -0x8000
4110       && imm_expr.X_add_number < 0x8000)
4111     macro_build (&imm_expr, unsignedp ? "sltiu" : "slti", "t,r,j",
4112                  AT, reg, BFD_RELOC_LO16);
4113   else
4114     {
4115       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
4116       macro_build (NULL, unsignedp ? "sltu" : "slt", "d,v,t", AT, reg, AT);
4117     }
4118 }
4119
4120 /* Warn if an expression is not a constant.  */
4121
4122 static void
4123 check_absolute_expr (struct mips_cl_insn *ip, expressionS *ex)
4124 {
4125   if (ex->X_op == O_big)
4126     as_bad (_("unsupported large constant"));
4127   else if (ex->X_op != O_constant)
4128     as_bad (_("Instruction %s requires absolute expression"),
4129             ip->insn_mo->name);
4130
4131   if (HAVE_32BIT_GPRS)
4132     normalize_constant_expr (ex);
4133 }
4134
4135 /* Count the leading zeroes by performing a binary chop. This is a
4136    bulky bit of source, but performance is a LOT better for the
4137    majority of values than a simple loop to count the bits:
4138        for (lcnt = 0; (lcnt < 32); lcnt++)
4139          if ((v) & (1 << (31 - lcnt)))
4140            break;
4141   However it is not code size friendly, and the gain will drop a bit
4142   on certain cached systems.
4143 */
4144 #define COUNT_TOP_ZEROES(v)             \
4145   (((v) & ~0xffff) == 0                 \
4146    ? ((v) & ~0xff) == 0                 \
4147      ? ((v) & ~0xf) == 0                \
4148        ? ((v) & ~0x3) == 0              \
4149          ? ((v) & ~0x1) == 0            \
4150            ? !(v)                       \
4151              ? 32                       \
4152              : 31                       \
4153            : 30                         \
4154          : ((v) & ~0x7) == 0            \
4155            ? 29                         \
4156            : 28                         \
4157        : ((v) & ~0x3f) == 0             \
4158          ? ((v) & ~0x1f) == 0           \
4159            ? 27                         \
4160            : 26                         \
4161          : ((v) & ~0x7f) == 0           \
4162            ? 25                         \
4163            : 24                         \
4164      : ((v) & ~0xfff) == 0              \
4165        ? ((v) & ~0x3ff) == 0            \
4166          ? ((v) & ~0x1ff) == 0          \
4167            ? 23                         \
4168            : 22                         \
4169          : ((v) & ~0x7ff) == 0          \
4170            ? 21                         \
4171            : 20                         \
4172        : ((v) & ~0x3fff) == 0           \
4173          ? ((v) & ~0x1fff) == 0         \
4174            ? 19                         \
4175            : 18                         \
4176          : ((v) & ~0x7fff) == 0         \
4177            ? 17                         \
4178            : 16                         \
4179    : ((v) & ~0xffffff) == 0             \
4180      ? ((v) & ~0xfffff) == 0            \
4181        ? ((v) & ~0x3ffff) == 0          \
4182          ? ((v) & ~0x1ffff) == 0        \
4183            ? 15                         \
4184            : 14                         \
4185          : ((v) & ~0x7ffff) == 0        \
4186            ? 13                         \
4187            : 12                         \
4188        : ((v) & ~0x3fffff) == 0         \
4189          ? ((v) & ~0x1fffff) == 0       \
4190            ? 11                         \
4191            : 10                         \
4192          : ((v) & ~0x7fffff) == 0       \
4193            ? 9                          \
4194            : 8                          \
4195      : ((v) & ~0xfffffff) == 0          \
4196        ? ((v) & ~0x3ffffff) == 0        \
4197          ? ((v) & ~0x1ffffff) == 0      \
4198            ? 7                          \
4199            : 6                          \
4200          : ((v) & ~0x7ffffff) == 0      \
4201            ? 5                          \
4202            : 4                          \
4203        : ((v) & ~0x3fffffff) == 0       \
4204          ? ((v) & ~0x1fffffff) == 0     \
4205            ? 3                          \
4206            : 2                          \
4207          : ((v) & ~0x7fffffff) == 0     \
4208            ? 1                          \
4209            : 0)
4210
4211 /*                      load_register()
4212  *  This routine generates the least number of instructions necessary to load
4213  *  an absolute expression value into a register.
4214  */
4215 static void
4216 load_register (int reg, expressionS *ep, int dbl)
4217 {
4218   int freg;
4219   expressionS hi32, lo32;
4220
4221   if (ep->X_op != O_big)
4222     {
4223       gas_assert (ep->X_op == O_constant);
4224
4225       /* Sign-extending 32-bit constants makes their handling easier.  */
4226       if (!dbl)
4227         normalize_constant_expr (ep);
4228
4229       if (IS_SEXT_16BIT_NUM (ep->X_add_number))
4230         {
4231           /* We can handle 16 bit signed values with an addiu to
4232              $zero.  No need to ever use daddiu here, since $zero and
4233              the result are always correct in 32 bit mode.  */
4234           macro_build (ep, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
4235           return;
4236         }
4237       else if (ep->X_add_number >= 0 && ep->X_add_number < 0x10000)
4238         {
4239           /* We can handle 16 bit unsigned values with an ori to
4240              $zero.  */
4241           macro_build (ep, "ori", "t,r,i", reg, 0, BFD_RELOC_LO16);
4242           return;
4243         }
4244       else if ((IS_SEXT_32BIT_NUM (ep->X_add_number)))
4245         {
4246           /* 32 bit values require an lui.  */
4247           macro_build (ep, "lui", "t,u", reg, BFD_RELOC_HI16);
4248           if ((ep->X_add_number & 0xffff) != 0)
4249             macro_build (ep, "ori", "t,r,i", reg, reg, BFD_RELOC_LO16);
4250           return;
4251         }
4252     }
4253
4254   /* The value is larger than 32 bits.  */
4255
4256   if (!dbl || HAVE_32BIT_GPRS)
4257     {
4258       char value[32];
4259
4260       sprintf_vma (value, ep->X_add_number);
4261       as_bad (_("Number (0x%s) larger than 32 bits"), value);
4262       macro_build (ep, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
4263       return;
4264     }
4265
4266   if (ep->X_op != O_big)
4267     {
4268       hi32 = *ep;
4269       hi32.X_add_number = (valueT) hi32.X_add_number >> 16;
4270       hi32.X_add_number = (valueT) hi32.X_add_number >> 16;
4271       hi32.X_add_number &= 0xffffffff;
4272       lo32 = *ep;
4273       lo32.X_add_number &= 0xffffffff;
4274     }
4275   else
4276     {
4277       gas_assert (ep->X_add_number > 2);
4278       if (ep->X_add_number == 3)
4279         generic_bignum[3] = 0;
4280       else if (ep->X_add_number > 4)
4281         as_bad (_("Number larger than 64 bits"));
4282       lo32.X_op = O_constant;
4283       lo32.X_add_number = generic_bignum[0] + (generic_bignum[1] << 16);
4284       hi32.X_op = O_constant;
4285       hi32.X_add_number = generic_bignum[2] + (generic_bignum[3] << 16);
4286     }
4287
4288   if (hi32.X_add_number == 0)
4289     freg = 0;
4290   else
4291     {
4292       int shift, bit;
4293       unsigned long hi, lo;
4294
4295       if (hi32.X_add_number == (offsetT) 0xffffffff)
4296         {
4297           if ((lo32.X_add_number & 0xffff8000) == 0xffff8000)
4298             {
4299               macro_build (&lo32, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
4300               return;
4301             }
4302           if (lo32.X_add_number & 0x80000000)
4303             {
4304               macro_build (&lo32, "lui", "t,u", reg, BFD_RELOC_HI16);
4305               if (lo32.X_add_number & 0xffff)
4306                 macro_build (&lo32, "ori", "t,r,i", reg, reg, BFD_RELOC_LO16);
4307               return;
4308             }
4309         }
4310
4311       /* Check for 16bit shifted constant.  We know that hi32 is
4312          non-zero, so start the mask on the first bit of the hi32
4313          value.  */
4314       shift = 17;
4315       do
4316         {
4317           unsigned long himask, lomask;
4318
4319           if (shift < 32)
4320             {
4321               himask = 0xffff >> (32 - shift);
4322               lomask = (0xffff << shift) & 0xffffffff;
4323             }
4324           else
4325             {
4326               himask = 0xffff << (shift - 32);
4327               lomask = 0;
4328             }
4329           if ((hi32.X_add_number & ~(offsetT) himask) == 0
4330               && (lo32.X_add_number & ~(offsetT) lomask) == 0)
4331             {
4332               expressionS tmp;
4333
4334               tmp.X_op = O_constant;
4335               if (shift < 32)
4336                 tmp.X_add_number = ((hi32.X_add_number << (32 - shift))
4337                                     | (lo32.X_add_number >> shift));
4338               else
4339                 tmp.X_add_number = hi32.X_add_number >> (shift - 32);
4340               macro_build (&tmp, "ori", "t,r,i", reg, 0, BFD_RELOC_LO16);
4341               macro_build (NULL, (shift >= 32) ? "dsll32" : "dsll", "d,w,<",
4342                            reg, reg, (shift >= 32) ? shift - 32 : shift);
4343               return;
4344             }
4345           ++shift;
4346         }
4347       while (shift <= (64 - 16));
4348
4349       /* Find the bit number of the lowest one bit, and store the
4350          shifted value in hi/lo.  */
4351       hi = (unsigned long) (hi32.X_add_number & 0xffffffff);
4352       lo = (unsigned long) (lo32.X_add_number & 0xffffffff);
4353       if (lo != 0)
4354         {
4355           bit = 0;
4356           while ((lo & 1) == 0)
4357             {
4358               lo >>= 1;
4359               ++bit;
4360             }
4361           lo |= (hi & (((unsigned long) 1 << bit) - 1)) << (32 - bit);
4362           hi >>= bit;
4363         }
4364       else
4365         {
4366           bit = 32;
4367           while ((hi & 1) == 0)
4368             {
4369               hi >>= 1;
4370               ++bit;
4371             }
4372           lo = hi;
4373           hi = 0;
4374         }
4375
4376       /* Optimize if the shifted value is a (power of 2) - 1.  */
4377       if ((hi == 0 && ((lo + 1) & lo) == 0)
4378           || (lo == 0xffffffff && ((hi + 1) & hi) == 0))
4379         {
4380           shift = COUNT_TOP_ZEROES ((unsigned int) hi32.X_add_number);
4381           if (shift != 0)
4382             {
4383               expressionS tmp;
4384
4385               /* This instruction will set the register to be all
4386                  ones.  */
4387               tmp.X_op = O_constant;
4388               tmp.X_add_number = (offsetT) -1;
4389               macro_build (&tmp, "addiu", "t,r,j", reg, 0, BFD_RELOC_LO16);
4390               if (bit != 0)
4391                 {
4392                   bit += shift;
4393                   macro_build (NULL, (bit >= 32) ? "dsll32" : "dsll", "d,w,<",
4394                                reg, reg, (bit >= 32) ? bit - 32 : bit);
4395                 }
4396               macro_build (NULL, (shift >= 32) ? "dsrl32" : "dsrl", "d,w,<",
4397                            reg, reg, (shift >= 32) ? shift - 32 : shift);
4398               return;
4399             }
4400         }
4401
4402       /* Sign extend hi32 before calling load_register, because we can
4403          generally get better code when we load a sign extended value.  */
4404       if ((hi32.X_add_number & 0x80000000) != 0)
4405         hi32.X_add_number |= ~(offsetT) 0xffffffff;
4406       load_register (reg, &hi32, 0);
4407       freg = reg;
4408     }
4409   if ((lo32.X_add_number & 0xffff0000) == 0)
4410     {
4411       if (freg != 0)
4412         {
4413           macro_build (NULL, "dsll32", "d,w,<", reg, freg, 0);
4414           freg = reg;
4415         }
4416     }
4417   else
4418     {
4419       expressionS mid16;
4420
4421       if ((freg == 0) && (lo32.X_add_number == (offsetT) 0xffffffff))
4422         {
4423           macro_build (&lo32, "lui", "t,u", reg, BFD_RELOC_HI16);
4424           macro_build (NULL, "dsrl32", "d,w,<", reg, reg, 0);
4425           return;
4426         }
4427
4428       if (freg != 0)
4429         {
4430           macro_build (NULL, "dsll", "d,w,<", reg, freg, 16);
4431           freg = reg;
4432         }
4433       mid16 = lo32;
4434       mid16.X_add_number >>= 16;
4435       macro_build (&mid16, "ori", "t,r,i", reg, freg, BFD_RELOC_LO16);
4436       macro_build (NULL, "dsll", "d,w,<", reg, reg, 16);
4437       freg = reg;
4438     }
4439   if ((lo32.X_add_number & 0xffff) != 0)
4440     macro_build (&lo32, "ori", "t,r,i", reg, freg, BFD_RELOC_LO16);
4441 }
4442
4443 static inline void
4444 load_delay_nop (void)
4445 {
4446   if (!gpr_interlocks)
4447     macro_build (NULL, "nop", "");
4448 }
4449
4450 /* Load an address into a register.  */
4451
4452 static void
4453 load_address (int reg, expressionS *ep, int *used_at)
4454 {
4455   if (ep->X_op != O_constant
4456       && ep->X_op != O_symbol)
4457     {
4458       as_bad (_("expression too complex"));
4459       ep->X_op = O_constant;
4460     }
4461
4462   if (ep->X_op == O_constant)
4463     {
4464       load_register (reg, ep, HAVE_64BIT_ADDRESSES);
4465       return;
4466     }
4467
4468   if (mips_pic == NO_PIC)
4469     {
4470       /* If this is a reference to a GP relative symbol, we want
4471            addiu        $reg,$gp,<sym>          (BFD_RELOC_GPREL16)
4472          Otherwise we want
4473            lui          $reg,<sym>              (BFD_RELOC_HI16_S)
4474            addiu        $reg,$reg,<sym>         (BFD_RELOC_LO16)
4475          If we have an addend, we always use the latter form.
4476
4477          With 64bit address space and a usable $at we want
4478            lui          $reg,<sym>              (BFD_RELOC_MIPS_HIGHEST)
4479            lui          $at,<sym>               (BFD_RELOC_HI16_S)
4480            daddiu       $reg,<sym>              (BFD_RELOC_MIPS_HIGHER)
4481            daddiu       $at,<sym>               (BFD_RELOC_LO16)
4482            dsll32       $reg,0
4483            daddu        $reg,$reg,$at
4484
4485          If $at is already in use, we use a path which is suboptimal
4486          on superscalar processors.
4487            lui          $reg,<sym>              (BFD_RELOC_MIPS_HIGHEST)
4488            daddiu       $reg,<sym>              (BFD_RELOC_MIPS_HIGHER)
4489            dsll         $reg,16
4490            daddiu       $reg,<sym>              (BFD_RELOC_HI16_S)
4491            dsll         $reg,16
4492            daddiu       $reg,<sym>              (BFD_RELOC_LO16)
4493
4494          For GP relative symbols in 64bit address space we can use
4495          the same sequence as in 32bit address space.  */
4496       if (HAVE_64BIT_SYMBOLS)
4497         {
4498           if ((valueT) ep->X_add_number <= MAX_GPREL_OFFSET
4499               && !nopic_need_relax (ep->X_add_symbol, 1))
4500             {
4501               relax_start (ep->X_add_symbol);
4502               macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg,
4503                            mips_gp_register, BFD_RELOC_GPREL16);
4504               relax_switch ();
4505             }
4506
4507           if (*used_at == 0 && mips_opts.at)
4508             {
4509               macro_build (ep, "lui", "t,u", reg, BFD_RELOC_MIPS_HIGHEST);
4510               macro_build (ep, "lui", "t,u", AT, BFD_RELOC_HI16_S);
4511               macro_build (ep, "daddiu", "t,r,j", reg, reg,
4512                            BFD_RELOC_MIPS_HIGHER);
4513               macro_build (ep, "daddiu", "t,r,j", AT, AT, BFD_RELOC_LO16);
4514               macro_build (NULL, "dsll32", "d,w,<", reg, reg, 0);
4515               macro_build (NULL, "daddu", "d,v,t", reg, reg, AT);
4516               *used_at = 1;
4517             }
4518           else
4519             {
4520               macro_build (ep, "lui", "t,u", reg, BFD_RELOC_MIPS_HIGHEST);
4521               macro_build (ep, "daddiu", "t,r,j", reg, reg,
4522                            BFD_RELOC_MIPS_HIGHER);
4523               macro_build (NULL, "dsll", "d,w,<", reg, reg, 16);
4524               macro_build (ep, "daddiu", "t,r,j", reg, reg, BFD_RELOC_HI16_S);
4525               macro_build (NULL, "dsll", "d,w,<", reg, reg, 16);
4526               macro_build (ep, "daddiu", "t,r,j", reg, reg, BFD_RELOC_LO16);
4527             }
4528
4529           if (mips_relax.sequence)
4530             relax_end ();
4531         }
4532       else
4533         {
4534           if ((valueT) ep->X_add_number <= MAX_GPREL_OFFSET
4535               && !nopic_need_relax (ep->X_add_symbol, 1))
4536             {
4537               relax_start (ep->X_add_symbol);
4538               macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg,
4539                            mips_gp_register, BFD_RELOC_GPREL16);
4540               relax_switch ();
4541             }
4542           macro_build_lui (ep, reg);
4543           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j",
4544                        reg, reg, BFD_RELOC_LO16);
4545           if (mips_relax.sequence)
4546             relax_end ();
4547         }
4548     }
4549   else if (!mips_big_got)
4550     {
4551       expressionS ex;
4552
4553       /* If this is a reference to an external symbol, we want
4554            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT16)
4555          Otherwise we want
4556            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT16)
4557            nop
4558            addiu        $reg,$reg,<sym>         (BFD_RELOC_LO16)
4559          If there is a constant, it must be added in after.
4560
4561          If we have NewABI, we want
4562            lw           $reg,<sym+cst>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
4563          unless we're referencing a global symbol with a non-zero
4564          offset, in which case cst must be added separately.  */
4565       if (HAVE_NEWABI)
4566         {
4567           if (ep->X_add_number)
4568             {
4569               ex.X_add_number = ep->X_add_number;
4570               ep->X_add_number = 0;
4571               relax_start (ep->X_add_symbol);
4572               macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
4573                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
4574               if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
4575                 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
4576               ex.X_op = O_constant;
4577               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j",
4578                            reg, reg, BFD_RELOC_LO16);
4579               ep->X_add_number = ex.X_add_number;
4580               relax_switch ();
4581             }
4582           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
4583                        BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
4584           if (mips_relax.sequence)
4585             relax_end ();
4586         }
4587       else
4588         {
4589           ex.X_add_number = ep->X_add_number;
4590           ep->X_add_number = 0;
4591           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
4592                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
4593           load_delay_nop ();
4594           relax_start (ep->X_add_symbol);
4595           relax_switch ();
4596           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
4597                        BFD_RELOC_LO16);
4598           relax_end ();
4599
4600           if (ex.X_add_number != 0)
4601             {
4602               if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
4603                 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
4604               ex.X_op = O_constant;
4605               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j",
4606                            reg, reg, BFD_RELOC_LO16);
4607             }
4608         }
4609     }
4610   else if (mips_big_got)
4611     {
4612       expressionS ex;
4613
4614       /* This is the large GOT case.  If this is a reference to an
4615          external symbol, we want
4616            lui          $reg,<sym>              (BFD_RELOC_MIPS_GOT_HI16)
4617            addu         $reg,$reg,$gp
4618            lw           $reg,<sym>($reg)        (BFD_RELOC_MIPS_GOT_LO16)
4619
4620          Otherwise, for a reference to a local symbol in old ABI, we want
4621            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT16)
4622            nop
4623            addiu        $reg,$reg,<sym>         (BFD_RELOC_LO16)
4624          If there is a constant, it must be added in after.
4625
4626          In the NewABI, for local symbols, with or without offsets, we want:
4627            lw           $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT_PAGE)
4628            addiu        $reg,$reg,<sym>         (BFD_RELOC_MIPS_GOT_OFST)
4629       */
4630       if (HAVE_NEWABI)
4631         {
4632           ex.X_add_number = ep->X_add_number;
4633           ep->X_add_number = 0;
4634           relax_start (ep->X_add_symbol);
4635           macro_build (ep, "lui", "t,u", reg, BFD_RELOC_MIPS_GOT_HI16);
4636           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
4637                        reg, reg, mips_gp_register);
4638           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)",
4639                        reg, BFD_RELOC_MIPS_GOT_LO16, reg);
4640           if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
4641             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
4642           else if (ex.X_add_number)
4643             {
4644               ex.X_op = O_constant;
4645               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
4646                            BFD_RELOC_LO16);
4647             }
4648
4649           ep->X_add_number = ex.X_add_number;
4650           relax_switch ();
4651           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
4652                        BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
4653           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
4654                        BFD_RELOC_MIPS_GOT_OFST);
4655           relax_end ();
4656         }
4657       else
4658         {
4659           ex.X_add_number = ep->X_add_number;
4660           ep->X_add_number = 0;
4661           relax_start (ep->X_add_symbol);
4662           macro_build (ep, "lui", "t,u", reg, BFD_RELOC_MIPS_GOT_HI16);
4663           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
4664                        reg, reg, mips_gp_register);
4665           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)",
4666                        reg, BFD_RELOC_MIPS_GOT_LO16, reg);
4667           relax_switch ();
4668           if (reg_needs_delay (mips_gp_register))
4669             {
4670               /* We need a nop before loading from $gp.  This special
4671                  check is required because the lui which starts the main
4672                  instruction stream does not refer to $gp, and so will not
4673                  insert the nop which may be required.  */
4674               macro_build (NULL, "nop", "");
4675             }
4676           macro_build (ep, ADDRESS_LOAD_INSN, "t,o(b)", reg,
4677                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
4678           load_delay_nop ();
4679           macro_build (ep, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
4680                        BFD_RELOC_LO16);
4681           relax_end ();
4682
4683           if (ex.X_add_number != 0)
4684             {
4685               if (ex.X_add_number < -0x8000 || ex.X_add_number >= 0x8000)
4686                 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
4687               ex.X_op = O_constant;
4688               macro_build (&ex, ADDRESS_ADDI_INSN, "t,r,j", reg, reg,
4689                            BFD_RELOC_LO16);
4690             }
4691         }
4692     }
4693   else
4694     abort ();
4695
4696   if (!mips_opts.at && *used_at == 1)
4697     as_bad (_("Macro used $at after \".set noat\""));
4698 }
4699
4700 /* Move the contents of register SOURCE into register DEST.  */
4701
4702 static void
4703 move_register (int dest, int source)
4704 {
4705   macro_build (NULL, HAVE_32BIT_GPRS ? "addu" : "daddu", "d,v,t",
4706                dest, source, 0);
4707 }
4708
4709 /* Emit an SVR4 PIC sequence to load address LOCAL into DEST, where
4710    LOCAL is the sum of a symbol and a 16-bit or 32-bit displacement.
4711    The two alternatives are:
4712
4713    Global symbol                Local sybmol
4714    -------------                ------------
4715    lw DEST,%got(SYMBOL)         lw DEST,%got(SYMBOL + OFFSET)
4716    ...                          ...
4717    addiu DEST,DEST,OFFSET       addiu DEST,DEST,%lo(SYMBOL + OFFSET)
4718
4719    load_got_offset emits the first instruction and add_got_offset
4720    emits the second for a 16-bit offset or add_got_offset_hilo emits
4721    a sequence to add a 32-bit offset using a scratch register.  */
4722
4723 static void
4724 load_got_offset (int dest, expressionS *local)
4725 {
4726   expressionS global;
4727
4728   global = *local;
4729   global.X_add_number = 0;
4730
4731   relax_start (local->X_add_symbol);
4732   macro_build (&global, ADDRESS_LOAD_INSN, "t,o(b)", dest,
4733                BFD_RELOC_MIPS_GOT16, mips_gp_register);
4734   relax_switch ();
4735   macro_build (local, ADDRESS_LOAD_INSN, "t,o(b)", dest,
4736                BFD_RELOC_MIPS_GOT16, mips_gp_register);
4737   relax_end ();
4738 }
4739
4740 static void
4741 add_got_offset (int dest, expressionS *local)
4742 {
4743   expressionS global;
4744
4745   global.X_op = O_constant;
4746   global.X_op_symbol = NULL;
4747   global.X_add_symbol = NULL;
4748   global.X_add_number = local->X_add_number;
4749
4750   relax_start (local->X_add_symbol);
4751   macro_build (&global, ADDRESS_ADDI_INSN, "t,r,j",
4752                dest, dest, BFD_RELOC_LO16);
4753   relax_switch ();
4754   macro_build (local, ADDRESS_ADDI_INSN, "t,r,j", dest, dest, BFD_RELOC_LO16);
4755   relax_end ();
4756 }
4757
4758 static void
4759 add_got_offset_hilo (int dest, expressionS *local, int tmp)
4760 {
4761   expressionS global;
4762   int hold_mips_optimize;
4763
4764   global.X_op = O_constant;
4765   global.X_op_symbol = NULL;
4766   global.X_add_symbol = NULL;
4767   global.X_add_number = local->X_add_number;
4768
4769   relax_start (local->X_add_symbol);
4770   load_register (tmp, &global, HAVE_64BIT_ADDRESSES);
4771   relax_switch ();
4772   /* Set mips_optimize around the lui instruction to avoid
4773      inserting an unnecessary nop after the lw.  */
4774   hold_mips_optimize = mips_optimize;
4775   mips_optimize = 2;
4776   macro_build_lui (&global, tmp);
4777   mips_optimize = hold_mips_optimize;
4778   macro_build (local, ADDRESS_ADDI_INSN, "t,r,j", tmp, tmp, BFD_RELOC_LO16);
4779   relax_end ();
4780
4781   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", dest, dest, tmp);
4782 }
4783
4784 /*
4785  *                      Build macros
4786  *   This routine implements the seemingly endless macro or synthesized
4787  * instructions and addressing modes in the mips assembly language. Many
4788  * of these macros are simple and are similar to each other. These could
4789  * probably be handled by some kind of table or grammar approach instead of
4790  * this verbose method. Others are not simple macros but are more like
4791  * optimizing code generation.
4792  *   One interesting optimization is when several store macros appear
4793  * consecutively that would load AT with the upper half of the same address.
4794  * The ensuing load upper instructions are ommited. This implies some kind
4795  * of global optimization. We currently only optimize within a single macro.
4796  *   For many of the load and store macros if the address is specified as a
4797  * constant expression in the first 64k of memory (ie ld $2,0x4000c) we
4798  * first load register 'at' with zero and use it as the base register. The
4799  * mips assembler simply uses register $zero. Just one tiny optimization
4800  * we're missing.
4801  */
4802 static void
4803 macro (struct mips_cl_insn *ip)
4804 {
4805   unsigned int treg, sreg, dreg, breg;
4806   unsigned int tempreg;
4807   int mask;
4808   int used_at = 0;
4809   expressionS expr1;
4810   const char *s;
4811   const char *s2;
4812   const char *fmt;
4813   int likely = 0;
4814   int dbl = 0;
4815   int coproc = 0;
4816   int lr = 0;
4817   int imm = 0;
4818   int call = 0;
4819   int off;
4820   offsetT maxnum;
4821   bfd_reloc_code_real_type r;
4822   int hold_mips_optimize;
4823
4824   gas_assert (! mips_opts.mips16);
4825
4826   treg = (ip->insn_opcode >> 16) & 0x1f;
4827   dreg = (ip->insn_opcode >> 11) & 0x1f;
4828   sreg = breg = (ip->insn_opcode >> 21) & 0x1f;
4829   mask = ip->insn_mo->mask;
4830
4831   expr1.X_op = O_constant;
4832   expr1.X_op_symbol = NULL;
4833   expr1.X_add_symbol = NULL;
4834   expr1.X_add_number = 1;
4835
4836   switch (mask)
4837     {
4838     case M_DABS:
4839       dbl = 1;
4840     case M_ABS:
4841       /* bgez $a0,.+12
4842          move v0,$a0
4843          sub v0,$zero,$a0
4844          */
4845
4846       start_noreorder ();
4847
4848       expr1.X_add_number = 8;
4849       macro_build (&expr1, "bgez", "s,p", sreg);
4850       if (dreg == sreg)
4851         macro_build (NULL, "nop", "", 0);
4852       else
4853         move_register (dreg, sreg);
4854       macro_build (NULL, dbl ? "dsub" : "sub", "d,v,t", dreg, 0, sreg);
4855
4856       end_noreorder ();
4857       break;
4858
4859     case M_ADD_I:
4860       s = "addi";
4861       s2 = "add";
4862       goto do_addi;
4863     case M_ADDU_I:
4864       s = "addiu";
4865       s2 = "addu";
4866       goto do_addi;
4867     case M_DADD_I:
4868       dbl = 1;
4869       s = "daddi";
4870       s2 = "dadd";
4871       goto do_addi;
4872     case M_DADDU_I:
4873       dbl = 1;
4874       s = "daddiu";
4875       s2 = "daddu";
4876     do_addi:
4877       if (imm_expr.X_op == O_constant
4878           && imm_expr.X_add_number >= -0x8000
4879           && imm_expr.X_add_number < 0x8000)
4880         {
4881           macro_build (&imm_expr, s, "t,r,j", treg, sreg, BFD_RELOC_LO16);
4882           break;
4883         }
4884       used_at = 1;
4885       load_register (AT, &imm_expr, dbl);
4886       macro_build (NULL, s2, "d,v,t", treg, sreg, AT);
4887       break;
4888
4889     case M_AND_I:
4890       s = "andi";
4891       s2 = "and";
4892       goto do_bit;
4893     case M_OR_I:
4894       s = "ori";
4895       s2 = "or";
4896       goto do_bit;
4897     case M_NOR_I:
4898       s = "";
4899       s2 = "nor";
4900       goto do_bit;
4901     case M_XOR_I:
4902       s = "xori";
4903       s2 = "xor";
4904     do_bit:
4905       if (imm_expr.X_op == O_constant
4906           && imm_expr.X_add_number >= 0
4907           && imm_expr.X_add_number < 0x10000)
4908         {
4909           if (mask != M_NOR_I)
4910             macro_build (&imm_expr, s, "t,r,i", treg, sreg, BFD_RELOC_LO16);
4911           else
4912             {
4913               macro_build (&imm_expr, "ori", "t,r,i",
4914                            treg, sreg, BFD_RELOC_LO16);
4915               macro_build (NULL, "nor", "d,v,t", treg, treg, 0);
4916             }
4917           break;
4918         }
4919
4920       used_at = 1;
4921       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
4922       macro_build (NULL, s2, "d,v,t", treg, sreg, AT);
4923       break;
4924
4925     case M_BALIGN:
4926       switch (imm_expr.X_add_number)
4927         {
4928         case 0:
4929           macro_build (NULL, "nop", "");
4930           break;
4931         case 2:
4932           macro_build (NULL, "packrl.ph", "d,s,t", treg, treg, sreg);
4933           break;
4934         default:
4935           macro_build (NULL, "balign", "t,s,2", treg, sreg,
4936                        (int)imm_expr.X_add_number);
4937           break;
4938         }
4939       break;
4940
4941     case M_BEQ_I:
4942       s = "beq";
4943       goto beq_i;
4944     case M_BEQL_I:
4945       s = "beql";
4946       likely = 1;
4947       goto beq_i;
4948     case M_BNE_I:
4949       s = "bne";
4950       goto beq_i;
4951     case M_BNEL_I:
4952       s = "bnel";
4953       likely = 1;
4954     beq_i:
4955       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
4956         {
4957           macro_build (&offset_expr, s, "s,t,p", sreg, 0);
4958           break;
4959         }
4960       used_at = 1;
4961       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
4962       macro_build (&offset_expr, s, "s,t,p", sreg, AT);
4963       break;
4964
4965     case M_BGEL:
4966       likely = 1;
4967     case M_BGE:
4968       if (treg == 0)
4969         {
4970           macro_build (&offset_expr, likely ? "bgezl" : "bgez", "s,p", sreg);
4971           break;
4972         }
4973       if (sreg == 0)
4974         {
4975           macro_build (&offset_expr, likely ? "blezl" : "blez", "s,p", treg);
4976           break;
4977         }
4978       used_at = 1;
4979       macro_build (NULL, "slt", "d,v,t", AT, sreg, treg);
4980       macro_build (&offset_expr, likely ? "beql" : "beq", "s,t,p", AT, 0);
4981       break;
4982
4983     case M_BGTL_I:
4984       likely = 1;
4985     case M_BGT_I:
4986       /* check for > max integer */
4987       maxnum = 0x7fffffff;
4988       if (HAVE_64BIT_GPRS && sizeof (maxnum) > 4)
4989         {
4990           maxnum <<= 16;
4991           maxnum |= 0xffff;
4992           maxnum <<= 16;
4993           maxnum |= 0xffff;
4994         }
4995       if (imm_expr.X_op == O_constant
4996           && imm_expr.X_add_number >= maxnum
4997           && (HAVE_32BIT_GPRS || sizeof (maxnum) > 4))
4998         {
4999         do_false:
5000           /* result is always false */
5001           if (! likely)
5002             macro_build (NULL, "nop", "", 0);
5003           else
5004             macro_build (&offset_expr, "bnel", "s,t,p", 0, 0);
5005           break;
5006         }
5007       if (imm_expr.X_op != O_constant)
5008         as_bad (_("Unsupported large constant"));
5009       ++imm_expr.X_add_number;
5010       /* FALLTHROUGH */
5011     case M_BGE_I:
5012     case M_BGEL_I:
5013       if (mask == M_BGEL_I)
5014         likely = 1;
5015       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
5016         {
5017           macro_build (&offset_expr, likely ? "bgezl" : "bgez", "s,p", sreg);
5018           break;
5019         }
5020       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
5021         {
5022           macro_build (&offset_expr, likely ? "bgtzl" : "bgtz", "s,p", sreg);
5023           break;
5024         }
5025       maxnum = 0x7fffffff;
5026       if (HAVE_64BIT_GPRS && sizeof (maxnum) > 4)
5027         {
5028           maxnum <<= 16;
5029           maxnum |= 0xffff;
5030           maxnum <<= 16;
5031           maxnum |= 0xffff;
5032         }
5033       maxnum = - maxnum - 1;
5034       if (imm_expr.X_op == O_constant
5035           && imm_expr.X_add_number <= maxnum
5036           && (HAVE_32BIT_GPRS || sizeof (maxnum) > 4))
5037         {
5038         do_true:
5039           /* result is always true */
5040           as_warn (_("Branch %s is always true"), ip->insn_mo->name);
5041           macro_build (&offset_expr, "b", "p");
5042           break;
5043         }
5044       used_at = 1;
5045       set_at (sreg, 0);
5046       macro_build (&offset_expr, likely ? "beql" : "beq", "s,t,p", AT, 0);
5047       break;
5048
5049     case M_BGEUL:
5050       likely = 1;
5051     case M_BGEU:
5052       if (treg == 0)
5053         goto do_true;
5054       if (sreg == 0)
5055         {
5056           macro_build (&offset_expr, likely ? "beql" : "beq",
5057                        "s,t,p", 0, treg);
5058           break;
5059         }
5060       used_at = 1;
5061       macro_build (NULL, "sltu", "d,v,t", AT, sreg, treg);
5062       macro_build (&offset_expr, likely ? "beql" : "beq", "s,t,p", AT, 0);
5063       break;
5064
5065     case M_BGTUL_I:
5066       likely = 1;
5067     case M_BGTU_I:
5068       if (sreg == 0
5069           || (HAVE_32BIT_GPRS
5070               && imm_expr.X_op == O_constant
5071               && imm_expr.X_add_number == (offsetT) 0xffffffff))
5072         goto do_false;
5073       if (imm_expr.X_op != O_constant)
5074         as_bad (_("Unsupported large constant"));
5075       ++imm_expr.X_add_number;
5076       /* FALLTHROUGH */
5077     case M_BGEU_I:
5078     case M_BGEUL_I:
5079       if (mask == M_BGEUL_I)
5080         likely = 1;
5081       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
5082         goto do_true;
5083       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
5084         {
5085           macro_build (&offset_expr, likely ? "bnel" : "bne",
5086                        "s,t,p", sreg, 0);
5087           break;
5088         }
5089       used_at = 1;
5090       set_at (sreg, 1);
5091       macro_build (&offset_expr, likely ? "beql" : "beq", "s,t,p", AT, 0);
5092       break;
5093
5094     case M_BGTL:
5095       likely = 1;
5096     case M_BGT:
5097       if (treg == 0)
5098         {
5099           macro_build (&offset_expr, likely ? "bgtzl" : "bgtz", "s,p", sreg);
5100           break;
5101         }
5102       if (sreg == 0)
5103         {
5104           macro_build (&offset_expr, likely ? "bltzl" : "bltz", "s,p", treg);
5105           break;
5106         }
5107       used_at = 1;
5108       macro_build (NULL, "slt", "d,v,t", AT, treg, sreg);
5109       macro_build (&offset_expr, likely ? "bnel" : "bne", "s,t,p", AT, 0);
5110       break;
5111
5112     case M_BGTUL:
5113       likely = 1;
5114     case M_BGTU:
5115       if (treg == 0)
5116         {
5117           macro_build (&offset_expr, likely ? "bnel" : "bne",
5118                        "s,t,p", sreg, 0);
5119           break;
5120         }
5121       if (sreg == 0)
5122         goto do_false;
5123       used_at = 1;
5124       macro_build (NULL, "sltu", "d,v,t", AT, treg, sreg);
5125       macro_build (&offset_expr, likely ? "bnel" : "bne", "s,t,p", AT, 0);
5126       break;
5127
5128     case M_BLEL:
5129       likely = 1;
5130     case M_BLE:
5131       if (treg == 0)
5132         {
5133           macro_build (&offset_expr, likely ? "blezl" : "blez", "s,p", sreg);
5134           break;
5135         }
5136       if (sreg == 0)
5137         {
5138           macro_build (&offset_expr, likely ? "bgezl" : "bgez", "s,p", treg);
5139           break;
5140         }
5141       used_at = 1;
5142       macro_build (NULL, "slt", "d,v,t", AT, treg, sreg);
5143       macro_build (&offset_expr, likely ? "beql" : "beq", "s,t,p", AT, 0);
5144       break;
5145
5146     case M_BLEL_I:
5147       likely = 1;
5148     case M_BLE_I:
5149       maxnum = 0x7fffffff;
5150       if (HAVE_64BIT_GPRS && sizeof (maxnum) > 4)
5151         {
5152           maxnum <<= 16;
5153           maxnum |= 0xffff;
5154           maxnum <<= 16;
5155           maxnum |= 0xffff;
5156         }
5157       if (imm_expr.X_op == O_constant
5158           && imm_expr.X_add_number >= maxnum
5159           && (HAVE_32BIT_GPRS || sizeof (maxnum) > 4))
5160         goto do_true;
5161       if (imm_expr.X_op != O_constant)
5162         as_bad (_("Unsupported large constant"));
5163       ++imm_expr.X_add_number;
5164       /* FALLTHROUGH */
5165     case M_BLT_I:
5166     case M_BLTL_I:
5167       if (mask == M_BLTL_I)
5168         likely = 1;
5169       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
5170         {
5171           macro_build (&offset_expr, likely ? "bltzl" : "bltz", "s,p", sreg);
5172           break;
5173         }
5174       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
5175         {
5176           macro_build (&offset_expr, likely ? "blezl" : "blez", "s,p", sreg);
5177           break;
5178         }
5179       used_at = 1;
5180       set_at (sreg, 0);
5181       macro_build (&offset_expr, likely ? "bnel" : "bne", "s,t,p", AT, 0);
5182       break;
5183
5184     case M_BLEUL:
5185       likely = 1;
5186     case M_BLEU:
5187       if (treg == 0)
5188         {
5189           macro_build (&offset_expr, likely ? "beql" : "beq",
5190                        "s,t,p", sreg, 0);
5191           break;
5192         }
5193       if (sreg == 0)
5194         goto do_true;
5195       used_at = 1;
5196       macro_build (NULL, "sltu", "d,v,t", AT, treg, sreg);
5197       macro_build (&offset_expr, likely ? "beql" : "beq", "s,t,p", AT, 0);
5198       break;
5199
5200     case M_BLEUL_I:
5201       likely = 1;
5202     case M_BLEU_I:
5203       if (sreg == 0
5204           || (HAVE_32BIT_GPRS
5205               && imm_expr.X_op == O_constant
5206               && imm_expr.X_add_number == (offsetT) 0xffffffff))
5207         goto do_true;
5208       if (imm_expr.X_op != O_constant)
5209         as_bad (_("Unsupported large constant"));
5210       ++imm_expr.X_add_number;
5211       /* FALLTHROUGH */
5212     case M_BLTU_I:
5213     case M_BLTUL_I:
5214       if (mask == M_BLTUL_I)
5215         likely = 1;
5216       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
5217         goto do_false;
5218       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
5219         {
5220           macro_build (&offset_expr, likely ? "beql" : "beq",
5221                        "s,t,p", sreg, 0);
5222           break;
5223         }
5224       used_at = 1;
5225       set_at (sreg, 1);
5226       macro_build (&offset_expr, likely ? "bnel" : "bne", "s,t,p", AT, 0);
5227       break;
5228
5229     case M_BLTL:
5230       likely = 1;
5231     case M_BLT:
5232       if (treg == 0)
5233         {
5234           macro_build (&offset_expr, likely ? "bltzl" : "bltz", "s,p", sreg);
5235           break;
5236         }
5237       if (sreg == 0)
5238         {
5239           macro_build (&offset_expr, likely ? "bgtzl" : "bgtz", "s,p", treg);
5240           break;
5241         }
5242       used_at = 1;
5243       macro_build (NULL, "slt", "d,v,t", AT, sreg, treg);
5244       macro_build (&offset_expr, likely ? "bnel" : "bne", "s,t,p", AT, 0);
5245       break;
5246
5247     case M_BLTUL:
5248       likely = 1;
5249     case M_BLTU:
5250       if (treg == 0)
5251         goto do_false;
5252       if (sreg == 0)
5253         {
5254           macro_build (&offset_expr, likely ? "bnel" : "bne",
5255                        "s,t,p", 0, treg);
5256           break;
5257         }
5258       used_at = 1;
5259       macro_build (NULL, "sltu", "d,v,t", AT, sreg, treg);
5260       macro_build (&offset_expr, likely ? "bnel" : "bne", "s,t,p", AT, 0);
5261       break;
5262
5263     case M_DEXT:
5264       {
5265         unsigned long pos;
5266         unsigned long size;
5267
5268         if (imm_expr.X_op != O_constant || imm2_expr.X_op != O_constant)
5269           {
5270             as_bad (_("Unsupported large constant"));
5271             pos = size = 1;
5272           }
5273         else
5274           {
5275             pos = (unsigned long) imm_expr.X_add_number;
5276             size = (unsigned long) imm2_expr.X_add_number;
5277           }
5278
5279         if (pos > 63)
5280           {
5281             as_bad (_("Improper position (%lu)"), pos);
5282             pos = 1;
5283           }
5284         if (size == 0 || size > 64
5285             || (pos + size - 1) > 63)
5286           {
5287             as_bad (_("Improper extract size (%lu, position %lu)"),
5288                     size, pos);
5289             size = 1;
5290           }
5291
5292         if (size <= 32 && pos < 32)
5293           {
5294             s = "dext";
5295             fmt = "t,r,+A,+C";
5296           }
5297         else if (size <= 32)
5298           {
5299             s = "dextu";
5300             fmt = "t,r,+E,+H";
5301           }
5302         else
5303           {
5304             s = "dextm";
5305             fmt = "t,r,+A,+G";
5306           }
5307         macro_build ((expressionS *) NULL, s, fmt, treg, sreg, pos, size - 1);
5308       }
5309       break;
5310
5311     case M_DINS:
5312       {
5313         unsigned long pos;
5314         unsigned long size;
5315
5316         if (imm_expr.X_op != O_constant || imm2_expr.X_op != O_constant)
5317           {
5318             as_bad (_("Unsupported large constant"));
5319             pos = size = 1;
5320           }
5321         else
5322           {
5323             pos = (unsigned long) imm_expr.X_add_number;
5324             size = (unsigned long) imm2_expr.X_add_number;
5325           }
5326
5327         if (pos > 63)
5328           {
5329             as_bad (_("Improper position (%lu)"), pos);
5330             pos = 1;
5331           }
5332         if (size == 0 || size > 64
5333             || (pos + size - 1) > 63)
5334           {
5335             as_bad (_("Improper insert size (%lu, position %lu)"),
5336                     size, pos);
5337             size = 1;
5338           }
5339
5340         if (pos < 32 && (pos + size - 1) < 32)
5341           {
5342             s = "dins";
5343             fmt = "t,r,+A,+B";
5344           }
5345         else if (pos >= 32)
5346           {
5347             s = "dinsu";
5348             fmt = "t,r,+E,+F";
5349           }
5350         else
5351           {
5352             s = "dinsm";
5353             fmt = "t,r,+A,+F";
5354           }
5355         macro_build ((expressionS *) NULL, s, fmt, treg, sreg, (int) pos,
5356                      (int) (pos + size - 1));
5357       }
5358       break;
5359
5360     case M_DDIV_3:
5361       dbl = 1;
5362     case M_DIV_3:
5363       s = "mflo";
5364       goto do_div3;
5365     case M_DREM_3:
5366       dbl = 1;
5367     case M_REM_3:
5368       s = "mfhi";
5369     do_div3:
5370       if (treg == 0)
5371         {
5372           as_warn (_("Divide by zero."));
5373           if (mips_trap)
5374             macro_build (NULL, "teq", "s,t,q", 0, 0, 7);
5375           else
5376             macro_build (NULL, "break", "c", 7);
5377           break;
5378         }
5379
5380       start_noreorder ();
5381       if (mips_trap)
5382         {
5383           macro_build (NULL, "teq", "s,t,q", treg, 0, 7);
5384           macro_build (NULL, dbl ? "ddiv" : "div", "z,s,t", sreg, treg);
5385         }
5386       else
5387         {
5388           expr1.X_add_number = 8;
5389           macro_build (&expr1, "bne", "s,t,p", treg, 0);
5390           macro_build (NULL, dbl ? "ddiv" : "div", "z,s,t", sreg, treg);
5391           macro_build (NULL, "break", "c", 7);
5392         }
5393       expr1.X_add_number = -1;
5394       used_at = 1;
5395       load_register (AT, &expr1, dbl);
5396       expr1.X_add_number = mips_trap ? (dbl ? 12 : 8) : (dbl ? 20 : 16);
5397       macro_build (&expr1, "bne", "s,t,p", treg, AT);
5398       if (dbl)
5399         {
5400           expr1.X_add_number = 1;
5401           load_register (AT, &expr1, dbl);
5402           macro_build (NULL, "dsll32", "d,w,<", AT, AT, 31);
5403         }
5404       else
5405         {
5406           expr1.X_add_number = 0x80000000;
5407           macro_build (&expr1, "lui", "t,u", AT, BFD_RELOC_HI16);
5408         }
5409       if (mips_trap)
5410         {
5411           macro_build (NULL, "teq", "s,t,q", sreg, AT, 6);
5412           /* We want to close the noreorder block as soon as possible, so
5413              that later insns are available for delay slot filling.  */
5414           end_noreorder ();
5415         }
5416       else
5417         {
5418           expr1.X_add_number = 8;
5419           macro_build (&expr1, "bne", "s,t,p", sreg, AT);
5420           macro_build (NULL, "nop", "", 0);
5421
5422           /* We want to close the noreorder block as soon as possible, so
5423              that later insns are available for delay slot filling.  */
5424           end_noreorder ();
5425
5426           macro_build (NULL, "break", "c", 6);
5427         }
5428       macro_build (NULL, s, "d", dreg);
5429       break;
5430
5431     case M_DIV_3I:
5432       s = "div";
5433       s2 = "mflo";
5434       goto do_divi;
5435     case M_DIVU_3I:
5436       s = "divu";
5437       s2 = "mflo";
5438       goto do_divi;
5439     case M_REM_3I:
5440       s = "div";
5441       s2 = "mfhi";
5442       goto do_divi;
5443     case M_REMU_3I:
5444       s = "divu";
5445       s2 = "mfhi";
5446       goto do_divi;
5447     case M_DDIV_3I:
5448       dbl = 1;
5449       s = "ddiv";
5450       s2 = "mflo";
5451       goto do_divi;
5452     case M_DDIVU_3I:
5453       dbl = 1;
5454       s = "ddivu";
5455       s2 = "mflo";
5456       goto do_divi;
5457     case M_DREM_3I:
5458       dbl = 1;
5459       s = "ddiv";
5460       s2 = "mfhi";
5461       goto do_divi;
5462     case M_DREMU_3I:
5463       dbl = 1;
5464       s = "ddivu";
5465       s2 = "mfhi";
5466     do_divi:
5467       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
5468         {
5469           as_warn (_("Divide by zero."));
5470           if (mips_trap)
5471             macro_build (NULL, "teq", "s,t,q", 0, 0, 7);
5472           else
5473             macro_build (NULL, "break", "c", 7);
5474           break;
5475         }
5476       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 1)
5477         {
5478           if (strcmp (s2, "mflo") == 0)
5479             move_register (dreg, sreg);
5480           else
5481             move_register (dreg, 0);
5482           break;
5483         }
5484       if (imm_expr.X_op == O_constant
5485           && imm_expr.X_add_number == -1
5486           && s[strlen (s) - 1] != 'u')
5487         {
5488           if (strcmp (s2, "mflo") == 0)
5489             {
5490               macro_build (NULL, dbl ? "dneg" : "neg", "d,w", dreg, sreg);
5491             }
5492           else
5493             move_register (dreg, 0);
5494           break;
5495         }
5496
5497       used_at = 1;
5498       load_register (AT, &imm_expr, dbl);
5499       macro_build (NULL, s, "z,s,t", sreg, AT);
5500       macro_build (NULL, s2, "d", dreg);
5501       break;
5502
5503     case M_DIVU_3:
5504       s = "divu";
5505       s2 = "mflo";
5506       goto do_divu3;
5507     case M_REMU_3:
5508       s = "divu";
5509       s2 = "mfhi";
5510       goto do_divu3;
5511     case M_DDIVU_3:
5512       s = "ddivu";
5513       s2 = "mflo";
5514       goto do_divu3;
5515     case M_DREMU_3:
5516       s = "ddivu";
5517       s2 = "mfhi";
5518     do_divu3:
5519       start_noreorder ();
5520       if (mips_trap)
5521         {
5522           macro_build (NULL, "teq", "s,t,q", treg, 0, 7);
5523           macro_build (NULL, s, "z,s,t", sreg, treg);
5524           /* We want to close the noreorder block as soon as possible, so
5525              that later insns are available for delay slot filling.  */
5526           end_noreorder ();
5527         }
5528       else
5529         {
5530           expr1.X_add_number = 8;
5531           macro_build (&expr1, "bne", "s,t,p", treg, 0);
5532           macro_build (NULL, s, "z,s,t", sreg, treg);
5533
5534           /* We want to close the noreorder block as soon as possible, so
5535              that later insns are available for delay slot filling.  */
5536           end_noreorder ();
5537           macro_build (NULL, "break", "c", 7);
5538         }
5539       macro_build (NULL, s2, "d", dreg);
5540       break;
5541
5542     case M_DLCA_AB:
5543       dbl = 1;
5544     case M_LCA_AB:
5545       call = 1;
5546       goto do_la;
5547     case M_DLA_AB:
5548       dbl = 1;
5549     case M_LA_AB:
5550     do_la:
5551       /* Load the address of a symbol into a register.  If breg is not
5552          zero, we then add a base register to it.  */
5553
5554       if (dbl && HAVE_32BIT_GPRS)
5555         as_warn (_("dla used to load 32-bit register"));
5556
5557       if (! dbl && HAVE_64BIT_OBJECTS)
5558         as_warn (_("la used to load 64-bit address"));
5559
5560       if (offset_expr.X_op == O_constant
5561           && offset_expr.X_add_number >= -0x8000
5562           && offset_expr.X_add_number < 0x8000)
5563         {
5564           macro_build (&offset_expr, ADDRESS_ADDI_INSN,
5565                        "t,r,j", treg, sreg, BFD_RELOC_LO16);
5566           break;
5567         }
5568
5569       if (mips_opts.at && (treg == breg))
5570         {
5571           tempreg = AT;
5572           used_at = 1;
5573         }
5574       else
5575         {
5576           tempreg = treg;
5577         }
5578
5579       if (offset_expr.X_op != O_symbol
5580           && offset_expr.X_op != O_constant)
5581         {
5582           as_bad (_("expression too complex"));
5583           offset_expr.X_op = O_constant;
5584         }
5585
5586       if (offset_expr.X_op == O_constant)
5587         load_register (tempreg, &offset_expr, HAVE_64BIT_ADDRESSES);
5588       else if (mips_pic == NO_PIC)
5589         {
5590           /* If this is a reference to a GP relative symbol, we want
5591                addiu    $tempreg,$gp,<sym>      (BFD_RELOC_GPREL16)
5592              Otherwise we want
5593                lui      $tempreg,<sym>          (BFD_RELOC_HI16_S)
5594                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
5595              If we have a constant, we need two instructions anyhow,
5596              so we may as well always use the latter form.
5597
5598              With 64bit address space and a usable $at we want
5599                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
5600                lui      $at,<sym>               (BFD_RELOC_HI16_S)
5601                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
5602                daddiu   $at,<sym>               (BFD_RELOC_LO16)
5603                dsll32   $tempreg,0
5604                daddu    $tempreg,$tempreg,$at
5605
5606              If $at is already in use, we use a path which is suboptimal
5607              on superscalar processors.
5608                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
5609                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
5610                dsll     $tempreg,16
5611                daddiu   $tempreg,<sym>          (BFD_RELOC_HI16_S)
5612                dsll     $tempreg,16
5613                daddiu   $tempreg,<sym>          (BFD_RELOC_LO16)
5614
5615              For GP relative symbols in 64bit address space we can use
5616              the same sequence as in 32bit address space.  */
5617           if (HAVE_64BIT_SYMBOLS)
5618             {
5619               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
5620                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
5621                 {
5622                   relax_start (offset_expr.X_add_symbol);
5623                   macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
5624                                tempreg, mips_gp_register, BFD_RELOC_GPREL16);
5625                   relax_switch ();
5626                 }
5627
5628               if (used_at == 0 && mips_opts.at)
5629                 {
5630                   macro_build (&offset_expr, "lui", "t,u",
5631                                tempreg, BFD_RELOC_MIPS_HIGHEST);
5632                   macro_build (&offset_expr, "lui", "t,u",
5633                                AT, BFD_RELOC_HI16_S);
5634                   macro_build (&offset_expr, "daddiu", "t,r,j",
5635                                tempreg, tempreg, BFD_RELOC_MIPS_HIGHER);
5636                   macro_build (&offset_expr, "daddiu", "t,r,j",
5637                                AT, AT, BFD_RELOC_LO16);
5638                   macro_build (NULL, "dsll32", "d,w,<", tempreg, tempreg, 0);
5639                   macro_build (NULL, "daddu", "d,v,t", tempreg, tempreg, AT);
5640                   used_at = 1;
5641                 }
5642               else
5643                 {
5644                   macro_build (&offset_expr, "lui", "t,u",
5645                                tempreg, BFD_RELOC_MIPS_HIGHEST);
5646                   macro_build (&offset_expr, "daddiu", "t,r,j",
5647                                tempreg, tempreg, BFD_RELOC_MIPS_HIGHER);
5648                   macro_build (NULL, "dsll", "d,w,<", tempreg, tempreg, 16);
5649                   macro_build (&offset_expr, "daddiu", "t,r,j",
5650                                tempreg, tempreg, BFD_RELOC_HI16_S);
5651                   macro_build (NULL, "dsll", "d,w,<", tempreg, tempreg, 16);
5652                   macro_build (&offset_expr, "daddiu", "t,r,j",
5653                                tempreg, tempreg, BFD_RELOC_LO16);
5654                 }
5655
5656               if (mips_relax.sequence)
5657                 relax_end ();
5658             }
5659           else
5660             {
5661               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
5662                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
5663                 {
5664                   relax_start (offset_expr.X_add_symbol);
5665                   macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
5666                                tempreg, mips_gp_register, BFD_RELOC_GPREL16);
5667                   relax_switch ();
5668                 }
5669               if (!IS_SEXT_32BIT_NUM (offset_expr.X_add_number))
5670                 as_bad (_("offset too large"));
5671               macro_build_lui (&offset_expr, tempreg);
5672               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
5673                            tempreg, tempreg, BFD_RELOC_LO16);
5674               if (mips_relax.sequence)
5675                 relax_end ();
5676             }
5677         }
5678       else if (!mips_big_got && !HAVE_NEWABI)
5679         {
5680           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT16;
5681
5682           /* If this is a reference to an external symbol, and there
5683              is no constant, we want
5684                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
5685              or for lca or if tempreg is PIC_CALL_REG
5686                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_CALL16)
5687              For a local symbol, we want
5688                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
5689                nop
5690                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
5691
5692              If we have a small constant, and this is a reference to
5693              an external symbol, we want
5694                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
5695                nop
5696                addiu    $tempreg,$tempreg,<constant>
5697              For a local symbol, we want the same instruction
5698              sequence, but we output a BFD_RELOC_LO16 reloc on the
5699              addiu instruction.
5700
5701              If we have a large constant, and this is a reference to
5702              an external symbol, we want
5703                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
5704                lui      $at,<hiconstant>
5705                addiu    $at,$at,<loconstant>
5706                addu     $tempreg,$tempreg,$at
5707              For a local symbol, we want the same instruction
5708              sequence, but we output a BFD_RELOC_LO16 reloc on the
5709              addiu instruction.
5710            */
5711
5712           if (offset_expr.X_add_number == 0)
5713             {
5714               if (mips_pic == SVR4_PIC
5715                   && breg == 0
5716                   && (call || tempreg == PIC_CALL_REG))
5717                 lw_reloc_type = (int) BFD_RELOC_MIPS_CALL16;
5718
5719               relax_start (offset_expr.X_add_symbol);
5720               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
5721                            lw_reloc_type, mips_gp_register);
5722               if (breg != 0)
5723                 {
5724                   /* We're going to put in an addu instruction using
5725                      tempreg, so we may as well insert the nop right
5726                      now.  */
5727                   load_delay_nop ();
5728                 }
5729               relax_switch ();
5730               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
5731                            tempreg, BFD_RELOC_MIPS_GOT16, mips_gp_register);
5732               load_delay_nop ();
5733               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
5734                            tempreg, tempreg, BFD_RELOC_LO16);
5735               relax_end ();
5736               /* FIXME: If breg == 0, and the next instruction uses
5737                  $tempreg, then if this variant case is used an extra
5738                  nop will be generated.  */
5739             }
5740           else if (offset_expr.X_add_number >= -0x8000
5741                    && offset_expr.X_add_number < 0x8000)
5742             {
5743               load_got_offset (tempreg, &offset_expr);
5744               load_delay_nop ();
5745               add_got_offset (tempreg, &offset_expr);
5746             }
5747           else
5748             {
5749               expr1.X_add_number = offset_expr.X_add_number;
5750               offset_expr.X_add_number =
5751                 ((offset_expr.X_add_number + 0x8000) & 0xffff) - 0x8000;
5752               load_got_offset (tempreg, &offset_expr);
5753               offset_expr.X_add_number = expr1.X_add_number;
5754               /* If we are going to add in a base register, and the
5755                  target register and the base register are the same,
5756                  then we are using AT as a temporary register.  Since
5757                  we want to load the constant into AT, we add our
5758                  current AT (from the global offset table) and the
5759                  register into the register now, and pretend we were
5760                  not using a base register.  */
5761               if (breg == treg)
5762                 {
5763                   load_delay_nop ();
5764                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5765                                treg, AT, breg);
5766                   breg = 0;
5767                   tempreg = treg;
5768                 }
5769               add_got_offset_hilo (tempreg, &offset_expr, AT);
5770               used_at = 1;
5771             }
5772         }
5773       else if (!mips_big_got && HAVE_NEWABI)
5774         {
5775           int add_breg_early = 0;
5776
5777           /* If this is a reference to an external, and there is no
5778              constant, or local symbol (*), with or without a
5779              constant, we want
5780                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
5781              or for lca or if tempreg is PIC_CALL_REG
5782                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_CALL16)
5783
5784              If we have a small constant, and this is a reference to
5785              an external symbol, we want
5786                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
5787                addiu    $tempreg,$tempreg,<constant>
5788
5789              If we have a large constant, and this is a reference to
5790              an external symbol, we want
5791                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_DISP)
5792                lui      $at,<hiconstant>
5793                addiu    $at,$at,<loconstant>
5794                addu     $tempreg,$tempreg,$at
5795
5796              (*) Other assemblers seem to prefer GOT_PAGE/GOT_OFST for
5797              local symbols, even though it introduces an additional
5798              instruction.  */
5799
5800           if (offset_expr.X_add_number)
5801             {
5802               expr1.X_add_number = offset_expr.X_add_number;
5803               offset_expr.X_add_number = 0;
5804
5805               relax_start (offset_expr.X_add_symbol);
5806               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
5807                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
5808
5809               if (expr1.X_add_number >= -0x8000
5810                   && expr1.X_add_number < 0x8000)
5811                 {
5812                   macro_build (&expr1, ADDRESS_ADDI_INSN, "t,r,j",
5813                                tempreg, tempreg, BFD_RELOC_LO16);
5814                 }
5815               else if (IS_SEXT_32BIT_NUM (expr1.X_add_number + 0x8000))
5816                 {
5817                   /* If we are going to add in a base register, and the
5818                      target register and the base register are the same,
5819                      then we are using AT as a temporary register.  Since
5820                      we want to load the constant into AT, we add our
5821                      current AT (from the global offset table) and the
5822                      register into the register now, and pretend we were
5823                      not using a base register.  */
5824                   if (breg != treg)
5825                     dreg = tempreg;
5826                   else
5827                     {
5828                       gas_assert (tempreg == AT);
5829                       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5830                                    treg, AT, breg);
5831                       dreg = treg;
5832                       add_breg_early = 1;
5833                     }
5834
5835                   load_register (AT, &expr1, HAVE_64BIT_ADDRESSES);
5836                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5837                                dreg, dreg, AT);
5838
5839                   used_at = 1;
5840                 }
5841               else
5842                 as_bad (_("PIC code offset overflow (max 32 signed bits)"));
5843
5844               relax_switch ();
5845               offset_expr.X_add_number = expr1.X_add_number;
5846
5847               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
5848                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
5849               if (add_breg_early)
5850                 {
5851                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5852                                treg, tempreg, breg);
5853                   breg = 0;
5854                   tempreg = treg;
5855                 }
5856               relax_end ();
5857             }
5858           else if (breg == 0 && (call || tempreg == PIC_CALL_REG))
5859             {
5860               relax_start (offset_expr.X_add_symbol);
5861               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
5862                            BFD_RELOC_MIPS_CALL16, mips_gp_register);
5863               relax_switch ();
5864               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
5865                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
5866               relax_end ();
5867             }
5868           else
5869             {
5870               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
5871                            BFD_RELOC_MIPS_GOT_DISP, mips_gp_register);
5872             }
5873         }
5874       else if (mips_big_got && !HAVE_NEWABI)
5875         {
5876           int gpdelay;
5877           int lui_reloc_type = (int) BFD_RELOC_MIPS_GOT_HI16;
5878           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT_LO16;
5879           int local_reloc_type = (int) BFD_RELOC_MIPS_GOT16;
5880
5881           /* This is the large GOT case.  If this is a reference to an
5882              external symbol, and there is no constant, we want
5883                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
5884                addu     $tempreg,$tempreg,$gp
5885                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
5886              or for lca or if tempreg is PIC_CALL_REG
5887                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_CALL_HI16)
5888                addu     $tempreg,$tempreg,$gp
5889                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_CALL_LO16)
5890              For a local symbol, we want
5891                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
5892                nop
5893                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
5894
5895              If we have a small constant, and this is a reference to
5896              an external symbol, we want
5897                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
5898                addu     $tempreg,$tempreg,$gp
5899                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
5900                nop
5901                addiu    $tempreg,$tempreg,<constant>
5902              For a local symbol, we want
5903                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
5904                nop
5905                addiu    $tempreg,$tempreg,<constant> (BFD_RELOC_LO16)
5906
5907              If we have a large constant, and this is a reference to
5908              an external symbol, we want
5909                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
5910                addu     $tempreg,$tempreg,$gp
5911                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
5912                lui      $at,<hiconstant>
5913                addiu    $at,$at,<loconstant>
5914                addu     $tempreg,$tempreg,$at
5915              For a local symbol, we want
5916                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
5917                lui      $at,<hiconstant>
5918                addiu    $at,$at,<loconstant>    (BFD_RELOC_LO16)
5919                addu     $tempreg,$tempreg,$at
5920           */
5921
5922           expr1.X_add_number = offset_expr.X_add_number;
5923           offset_expr.X_add_number = 0;
5924           relax_start (offset_expr.X_add_symbol);
5925           gpdelay = reg_needs_delay (mips_gp_register);
5926           if (expr1.X_add_number == 0 && breg == 0
5927               && (call || tempreg == PIC_CALL_REG))
5928             {
5929               lui_reloc_type = (int) BFD_RELOC_MIPS_CALL_HI16;
5930               lw_reloc_type = (int) BFD_RELOC_MIPS_CALL_LO16;
5931             }
5932           macro_build (&offset_expr, "lui", "t,u", tempreg, lui_reloc_type);
5933           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5934                        tempreg, tempreg, mips_gp_register);
5935           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
5936                        tempreg, lw_reloc_type, tempreg);
5937           if (expr1.X_add_number == 0)
5938             {
5939               if (breg != 0)
5940                 {
5941                   /* We're going to put in an addu instruction using
5942                      tempreg, so we may as well insert the nop right
5943                      now.  */
5944                   load_delay_nop ();
5945                 }
5946             }
5947           else if (expr1.X_add_number >= -0x8000
5948                    && expr1.X_add_number < 0x8000)
5949             {
5950               load_delay_nop ();
5951               macro_build (&expr1, ADDRESS_ADDI_INSN, "t,r,j",
5952                            tempreg, tempreg, BFD_RELOC_LO16);
5953             }
5954           else
5955             {
5956               /* If we are going to add in a base register, and the
5957                  target register and the base register are the same,
5958                  then we are using AT as a temporary register.  Since
5959                  we want to load the constant into AT, we add our
5960                  current AT (from the global offset table) and the
5961                  register into the register now, and pretend we were
5962                  not using a base register.  */
5963               if (breg != treg)
5964                 dreg = tempreg;
5965               else
5966                 {
5967                   gas_assert (tempreg == AT);
5968                   load_delay_nop ();
5969                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
5970                                treg, AT, breg);
5971                   dreg = treg;
5972                 }
5973
5974               load_register (AT, &expr1, HAVE_64BIT_ADDRESSES);
5975               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", dreg, dreg, AT);
5976
5977               used_at = 1;
5978             }
5979           offset_expr.X_add_number =
5980             ((expr1.X_add_number + 0x8000) & 0xffff) - 0x8000;
5981           relax_switch ();
5982
5983           if (gpdelay)
5984             {
5985               /* This is needed because this instruction uses $gp, but
5986                  the first instruction on the main stream does not.  */
5987               macro_build (NULL, "nop", "");
5988             }
5989
5990           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
5991                        local_reloc_type, mips_gp_register);
5992           if (expr1.X_add_number >= -0x8000
5993               && expr1.X_add_number < 0x8000)
5994             {
5995               load_delay_nop ();
5996               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
5997                            tempreg, tempreg, BFD_RELOC_LO16);
5998               /* FIXME: If add_number is 0, and there was no base
5999                  register, the external symbol case ended with a load,
6000                  so if the symbol turns out to not be external, and
6001                  the next instruction uses tempreg, an unnecessary nop
6002                  will be inserted.  */
6003             }
6004           else
6005             {
6006               if (breg == treg)
6007                 {
6008                   /* We must add in the base register now, as in the
6009                      external symbol case.  */
6010                   gas_assert (tempreg == AT);
6011                   load_delay_nop ();
6012                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6013                                treg, AT, breg);
6014                   tempreg = treg;
6015                   /* We set breg to 0 because we have arranged to add
6016                      it in in both cases.  */
6017                   breg = 0;
6018                 }
6019
6020               macro_build_lui (&expr1, AT);
6021               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
6022                            AT, AT, BFD_RELOC_LO16);
6023               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6024                            tempreg, tempreg, AT);
6025               used_at = 1;
6026             }
6027           relax_end ();
6028         }
6029       else if (mips_big_got && HAVE_NEWABI)
6030         {
6031           int lui_reloc_type = (int) BFD_RELOC_MIPS_GOT_HI16;
6032           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT_LO16;
6033           int add_breg_early = 0;
6034
6035           /* This is the large GOT case.  If this is a reference to an
6036              external symbol, and there is no constant, we want
6037                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
6038                add      $tempreg,$tempreg,$gp
6039                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
6040              or for lca or if tempreg is PIC_CALL_REG
6041                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_CALL_HI16)
6042                add      $tempreg,$tempreg,$gp
6043                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_CALL_LO16)
6044
6045              If we have a small constant, and this is a reference to
6046              an external symbol, we want
6047                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
6048                add      $tempreg,$tempreg,$gp
6049                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
6050                addi     $tempreg,$tempreg,<constant>
6051
6052              If we have a large constant, and this is a reference to
6053              an external symbol, we want
6054                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
6055                addu     $tempreg,$tempreg,$gp
6056                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
6057                lui      $at,<hiconstant>
6058                addi     $at,$at,<loconstant>
6059                add      $tempreg,$tempreg,$at
6060
6061              If we have NewABI, and we know it's a local symbol, we want
6062                lw       $reg,<sym>($gp)         (BFD_RELOC_MIPS_GOT_PAGE)
6063                addiu    $reg,$reg,<sym>         (BFD_RELOC_MIPS_GOT_OFST)
6064              otherwise we have to resort to GOT_HI16/GOT_LO16.  */
6065
6066           relax_start (offset_expr.X_add_symbol);
6067
6068           expr1.X_add_number = offset_expr.X_add_number;
6069           offset_expr.X_add_number = 0;
6070
6071           if (expr1.X_add_number == 0 && breg == 0
6072               && (call || tempreg == PIC_CALL_REG))
6073             {
6074               lui_reloc_type = (int) BFD_RELOC_MIPS_CALL_HI16;
6075               lw_reloc_type = (int) BFD_RELOC_MIPS_CALL_LO16;
6076             }
6077           macro_build (&offset_expr, "lui", "t,u", tempreg, lui_reloc_type);
6078           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6079                        tempreg, tempreg, mips_gp_register);
6080           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6081                        tempreg, lw_reloc_type, tempreg);
6082
6083           if (expr1.X_add_number == 0)
6084             ;
6085           else if (expr1.X_add_number >= -0x8000
6086                    && expr1.X_add_number < 0x8000)
6087             {
6088               macro_build (&expr1, ADDRESS_ADDI_INSN, "t,r,j",
6089                            tempreg, tempreg, BFD_RELOC_LO16);
6090             }
6091           else if (IS_SEXT_32BIT_NUM (expr1.X_add_number + 0x8000))
6092             {
6093               /* If we are going to add in a base register, and the
6094                  target register and the base register are the same,
6095                  then we are using AT as a temporary register.  Since
6096                  we want to load the constant into AT, we add our
6097                  current AT (from the global offset table) and the
6098                  register into the register now, and pretend we were
6099                  not using a base register.  */
6100               if (breg != treg)
6101                 dreg = tempreg;
6102               else
6103                 {
6104                   gas_assert (tempreg == AT);
6105                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6106                                treg, AT, breg);
6107                   dreg = treg;
6108                   add_breg_early = 1;
6109                 }
6110
6111               load_register (AT, &expr1, HAVE_64BIT_ADDRESSES);
6112               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", dreg, dreg, AT);
6113
6114               used_at = 1;
6115             }
6116           else
6117             as_bad (_("PIC code offset overflow (max 32 signed bits)"));
6118
6119           relax_switch ();
6120           offset_expr.X_add_number = expr1.X_add_number;
6121           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
6122                        BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
6123           macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j", tempreg,
6124                        tempreg, BFD_RELOC_MIPS_GOT_OFST);
6125           if (add_breg_early)
6126             {
6127               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6128                            treg, tempreg, breg);
6129               breg = 0;
6130               tempreg = treg;
6131             }
6132           relax_end ();
6133         }
6134       else
6135         abort ();
6136
6137       if (breg != 0)
6138         macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", treg, tempreg, breg);
6139       break;
6140
6141     case M_MSGSND:
6142       {
6143         unsigned long temp = (treg << 16) | (0x01);
6144         macro_build (NULL, "c2", "C", temp);
6145       }
6146       /* AT is not used, just return */
6147       return;
6148
6149     case M_MSGLD:
6150       {
6151         unsigned long temp = (0x02);
6152         macro_build (NULL, "c2", "C", temp);
6153       }
6154       /* AT is not used, just return */
6155       return;
6156
6157     case M_MSGLD_T:
6158       {
6159         unsigned long temp = (treg << 16) | (0x02);
6160         macro_build (NULL, "c2", "C", temp);
6161       }
6162       /* AT is not used, just return */
6163       return;
6164
6165     case M_MSGWAIT:
6166       macro_build (NULL, "c2", "C", 3);
6167       /* AT is not used, just return */
6168       return;
6169
6170     case M_MSGWAIT_T:
6171       {
6172         unsigned long temp = (treg << 16) | 0x03;
6173         macro_build (NULL, "c2", "C", temp);
6174       }
6175       /* AT is not used, just return */
6176       return;
6177
6178     case M_J_A:
6179       /* The j instruction may not be used in PIC code, since it
6180          requires an absolute address.  We convert it to a b
6181          instruction.  */
6182       if (mips_pic == NO_PIC)
6183         macro_build (&offset_expr, "j", "a");
6184       else
6185         macro_build (&offset_expr, "b", "p");
6186       break;
6187
6188       /* The jal instructions must be handled as macros because when
6189          generating PIC code they expand to multi-instruction
6190          sequences.  Normally they are simple instructions.  */
6191     case M_JAL_1:
6192       dreg = RA;
6193       /* Fall through.  */
6194     case M_JAL_2:
6195       if (mips_pic == NO_PIC)
6196         macro_build (NULL, "jalr", "d,s", dreg, sreg);
6197       else
6198         {
6199           if (sreg != PIC_CALL_REG)
6200             as_warn (_("MIPS PIC call to register other than $25"));
6201
6202           macro_build (NULL, "jalr", "d,s", dreg, sreg);
6203           if (mips_pic == SVR4_PIC && !HAVE_NEWABI)
6204             {
6205               if (mips_cprestore_offset < 0)
6206                 as_warn (_("No .cprestore pseudo-op used in PIC code"));
6207               else
6208                 {
6209                   if (! mips_frame_reg_valid)
6210                     {
6211                       as_warn (_("No .frame pseudo-op used in PIC code"));
6212                       /* Quiet this warning.  */
6213                       mips_frame_reg_valid = 1;
6214                     }
6215                   if (! mips_cprestore_valid)
6216                     {
6217                       as_warn (_("No .cprestore pseudo-op used in PIC code"));
6218                       /* Quiet this warning.  */
6219                       mips_cprestore_valid = 1;
6220                     }
6221                   if (mips_opts.noreorder)
6222                     macro_build (NULL, "nop", "");
6223                   expr1.X_add_number = mips_cprestore_offset;
6224                   macro_build_ldst_constoffset (&expr1, ADDRESS_LOAD_INSN,
6225                                                 mips_gp_register,
6226                                                 mips_frame_reg,
6227                                                 HAVE_64BIT_ADDRESSES);
6228                 }
6229             }
6230         }
6231
6232       break;
6233
6234     case M_JAL_A:
6235       if (mips_pic == NO_PIC)
6236         macro_build (&offset_expr, "jal", "a");
6237       else if (mips_pic == SVR4_PIC)
6238         {
6239           /* If this is a reference to an external symbol, and we are
6240              using a small GOT, we want
6241                lw       $25,<sym>($gp)          (BFD_RELOC_MIPS_CALL16)
6242                nop
6243                jalr     $ra,$25
6244                nop
6245                lw       $gp,cprestore($sp)
6246              The cprestore value is set using the .cprestore
6247              pseudo-op.  If we are using a big GOT, we want
6248                lui      $25,<sym>               (BFD_RELOC_MIPS_CALL_HI16)
6249                addu     $25,$25,$gp
6250                lw       $25,<sym>($25)          (BFD_RELOC_MIPS_CALL_LO16)
6251                nop
6252                jalr     $ra,$25
6253                nop
6254                lw       $gp,cprestore($sp)
6255              If the symbol is not external, we want
6256                lw       $25,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
6257                nop
6258                addiu    $25,$25,<sym>           (BFD_RELOC_LO16)
6259                jalr     $ra,$25
6260                nop
6261                lw $gp,cprestore($sp)
6262
6263              For NewABI, we use the same CALL16 or CALL_HI16/CALL_LO16
6264              sequences above, minus nops, unless the symbol is local,
6265              which enables us to use GOT_PAGE/GOT_OFST (big got) or
6266              GOT_DISP.  */
6267           if (HAVE_NEWABI)
6268             {
6269               if (! mips_big_got)
6270                 {
6271                   relax_start (offset_expr.X_add_symbol);
6272                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6273                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL16,
6274                                mips_gp_register);
6275                   relax_switch ();
6276                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6277                                PIC_CALL_REG, BFD_RELOC_MIPS_GOT_DISP,
6278                                mips_gp_register);
6279                   relax_end ();
6280                 }
6281               else
6282                 {
6283                   relax_start (offset_expr.X_add_symbol);
6284                   macro_build (&offset_expr, "lui", "t,u", PIC_CALL_REG,
6285                                BFD_RELOC_MIPS_CALL_HI16);
6286                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", PIC_CALL_REG,
6287                                PIC_CALL_REG, mips_gp_register);
6288                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6289                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL_LO16,
6290                                PIC_CALL_REG);
6291                   relax_switch ();
6292                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6293                                PIC_CALL_REG, BFD_RELOC_MIPS_GOT_PAGE,
6294                                mips_gp_register);
6295                   macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
6296                                PIC_CALL_REG, PIC_CALL_REG,
6297                                BFD_RELOC_MIPS_GOT_OFST);
6298                   relax_end ();
6299                 }
6300
6301               macro_build_jalr (&offset_expr);
6302             }
6303           else
6304             {
6305               relax_start (offset_expr.X_add_symbol);
6306               if (! mips_big_got)
6307                 {
6308                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6309                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL16,
6310                                mips_gp_register);
6311                   load_delay_nop ();
6312                   relax_switch ();
6313                 }
6314               else
6315                 {
6316                   int gpdelay;
6317
6318                   gpdelay = reg_needs_delay (mips_gp_register);
6319                   macro_build (&offset_expr, "lui", "t,u", PIC_CALL_REG,
6320                                BFD_RELOC_MIPS_CALL_HI16);
6321                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", PIC_CALL_REG,
6322                                PIC_CALL_REG, mips_gp_register);
6323                   macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6324                                PIC_CALL_REG, BFD_RELOC_MIPS_CALL_LO16,
6325                                PIC_CALL_REG);
6326                   load_delay_nop ();
6327                   relax_switch ();
6328                   if (gpdelay)
6329                     macro_build (NULL, "nop", "");
6330                 }
6331               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
6332                            PIC_CALL_REG, BFD_RELOC_MIPS_GOT16,
6333                            mips_gp_register);
6334               load_delay_nop ();
6335               macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j",
6336                            PIC_CALL_REG, PIC_CALL_REG, BFD_RELOC_LO16);
6337               relax_end ();
6338               macro_build_jalr (&offset_expr);
6339
6340               if (mips_cprestore_offset < 0)
6341                 as_warn (_("No .cprestore pseudo-op used in PIC code"));
6342               else
6343                 {
6344                   if (! mips_frame_reg_valid)
6345                     {
6346                       as_warn (_("No .frame pseudo-op used in PIC code"));
6347                       /* Quiet this warning.  */
6348                       mips_frame_reg_valid = 1;
6349                     }
6350                   if (! mips_cprestore_valid)
6351                     {
6352                       as_warn (_("No .cprestore pseudo-op used in PIC code"));
6353                       /* Quiet this warning.  */
6354                       mips_cprestore_valid = 1;
6355                     }
6356                   if (mips_opts.noreorder)
6357                     macro_build (NULL, "nop", "");
6358                   expr1.X_add_number = mips_cprestore_offset;
6359                   macro_build_ldst_constoffset (&expr1, ADDRESS_LOAD_INSN,
6360                                                 mips_gp_register,
6361                                                 mips_frame_reg,
6362                                                 HAVE_64BIT_ADDRESSES);
6363                 }
6364             }
6365         }
6366       else if (mips_pic == VXWORKS_PIC)
6367         as_bad (_("Non-PIC jump used in PIC library"));
6368       else
6369         abort ();
6370
6371       break;
6372
6373     case M_LB_AB:
6374       s = "lb";
6375       goto ld;
6376     case M_LBU_AB:
6377       s = "lbu";
6378       goto ld;
6379     case M_LH_AB:
6380       s = "lh";
6381       goto ld;
6382     case M_LHU_AB:
6383       s = "lhu";
6384       goto ld;
6385     case M_LW_AB:
6386       s = "lw";
6387       goto ld;
6388     case M_LWC0_AB:
6389       s = "lwc0";
6390       /* Itbl support may require additional care here.  */
6391       coproc = 1;
6392       goto ld;
6393     case M_LWC1_AB:
6394       s = "lwc1";
6395       /* Itbl support may require additional care here.  */
6396       coproc = 1;
6397       goto ld;
6398     case M_LWC2_AB:
6399       s = "lwc2";
6400       /* Itbl support may require additional care here.  */
6401       coproc = 1;
6402       goto ld;
6403     case M_LWC3_AB:
6404       s = "lwc3";
6405       /* Itbl support may require additional care here.  */
6406       coproc = 1;
6407       goto ld;
6408     case M_LWL_AB:
6409       s = "lwl";
6410       lr = 1;
6411       goto ld;
6412     case M_LWR_AB:
6413       s = "lwr";
6414       lr = 1;
6415       goto ld;
6416     case M_LDC1_AB:
6417       s = "ldc1";
6418       /* Itbl support may require additional care here.  */
6419       coproc = 1;
6420       goto ld;
6421     case M_LDC2_AB:
6422       s = "ldc2";
6423       /* Itbl support may require additional care here.  */
6424       coproc = 1;
6425       goto ld;
6426     case M_LDC3_AB:
6427       s = "ldc3";
6428       /* Itbl support may require additional care here.  */
6429       coproc = 1;
6430       goto ld;
6431     case M_LDL_AB:
6432       s = "ldl";
6433       lr = 1;
6434       goto ld;
6435     case M_LDR_AB:
6436       s = "ldr";
6437       lr = 1;
6438       goto ld;
6439     case M_LL_AB:
6440       s = "ll";
6441       goto ld;
6442     case M_LLD_AB:
6443       s = "lld";
6444       goto ld;
6445     case M_LWU_AB:
6446       s = "lwu";
6447     ld:
6448       if (breg == treg || coproc || lr)
6449         {
6450           tempreg = AT;
6451           used_at = 1;
6452         }
6453       else
6454         {
6455           tempreg = treg;
6456         }
6457       goto ld_st;
6458     case M_SB_AB:
6459       s = "sb";
6460       goto st;
6461     case M_SH_AB:
6462       s = "sh";
6463       goto st;
6464     case M_SW_AB:
6465       s = "sw";
6466       goto st;
6467     case M_SWC0_AB:
6468       s = "swc0";
6469       /* Itbl support may require additional care here.  */
6470       coproc = 1;
6471       goto st;
6472     case M_SWC1_AB:
6473       s = "swc1";
6474       /* Itbl support may require additional care here.  */
6475       coproc = 1;
6476       goto st;
6477     case M_SWC2_AB:
6478       s = "swc2";
6479       /* Itbl support may require additional care here.  */
6480       coproc = 1;
6481       goto st;
6482     case M_SWC3_AB:
6483       s = "swc3";
6484       /* Itbl support may require additional care here.  */
6485       coproc = 1;
6486       goto st;
6487     case M_SWL_AB:
6488       s = "swl";
6489       goto st;
6490     case M_SWR_AB:
6491       s = "swr";
6492       goto st;
6493     case M_SC_AB:
6494       s = "sc";
6495       goto st;
6496     case M_SCD_AB:
6497       s = "scd";
6498       goto st;
6499     case M_CACHE_AB:
6500       s = "cache";
6501       goto st;
6502     case M_SDC1_AB:
6503       s = "sdc1";
6504       coproc = 1;
6505       /* Itbl support may require additional care here.  */
6506       goto st;
6507     case M_SDC2_AB:
6508       s = "sdc2";
6509       /* Itbl support may require additional care here.  */
6510       coproc = 1;
6511       goto st;
6512     case M_SDC3_AB:
6513       s = "sdc3";
6514       /* Itbl support may require additional care here.  */
6515       coproc = 1;
6516       goto st;
6517     case M_SDL_AB:
6518       s = "sdl";
6519       goto st;
6520     case M_SDR_AB:
6521       s = "sdr";
6522     st:
6523       tempreg = AT;
6524       used_at = 1;
6525     ld_st:
6526       if (coproc
6527           && NO_ISA_COP (mips_opts.arch)
6528           && (ip->insn_mo->pinfo2 & (INSN2_M_FP_S | INSN2_M_FP_D)) == 0)
6529         {
6530           as_bad (_("opcode not supported on this processor: %s"),
6531                   mips_cpu_info_from_arch (mips_opts.arch)->name);
6532           break;
6533         }
6534
6535       /* Itbl support may require additional care here.  */
6536       if (mask == M_LWC1_AB
6537           || mask == M_SWC1_AB
6538           || mask == M_LDC1_AB
6539           || mask == M_SDC1_AB
6540           || mask == M_L_DAB
6541           || mask == M_S_DAB)
6542         fmt = "T,o(b)";
6543       else if (mask == M_CACHE_AB)
6544         fmt = "k,o(b)";
6545       else if (coproc)
6546         fmt = "E,o(b)";
6547       else
6548         fmt = "t,o(b)";
6549
6550       if (offset_expr.X_op != O_constant
6551           && offset_expr.X_op != O_symbol)
6552         {
6553           as_bad (_("expression too complex"));
6554           offset_expr.X_op = O_constant;
6555         }
6556
6557       if (HAVE_32BIT_ADDRESSES
6558           && !IS_SEXT_32BIT_NUM (offset_expr.X_add_number))
6559         {
6560           char value [32];
6561
6562           sprintf_vma (value, offset_expr.X_add_number);
6563           as_bad (_("Number (0x%s) larger than 32 bits"), value);
6564         }
6565
6566       /* A constant expression in PIC code can be handled just as it
6567          is in non PIC code.  */
6568       if (offset_expr.X_op == O_constant)
6569         {
6570           expr1.X_add_number = ((offset_expr.X_add_number + 0x8000)
6571                                 & ~(bfd_vma) 0xffff);
6572           normalize_address_expr (&expr1);
6573           load_register (tempreg, &expr1, HAVE_64BIT_ADDRESSES);
6574           if (breg != 0)
6575             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6576                          tempreg, tempreg, breg);
6577           macro_build (&offset_expr, s, fmt, treg, BFD_RELOC_LO16, tempreg);
6578         }
6579       else if (mips_pic == NO_PIC)
6580         {
6581           /* If this is a reference to a GP relative symbol, and there
6582              is no base register, we want
6583                <op>     $treg,<sym>($gp)        (BFD_RELOC_GPREL16)
6584              Otherwise, if there is no base register, we want
6585                lui      $tempreg,<sym>          (BFD_RELOC_HI16_S)
6586                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
6587              If we have a constant, we need two instructions anyhow,
6588              so we always use the latter form.
6589
6590              If we have a base register, and this is a reference to a
6591              GP relative symbol, we want
6592                addu     $tempreg,$breg,$gp
6593                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_GPREL16)
6594              Otherwise we want
6595                lui      $tempreg,<sym>          (BFD_RELOC_HI16_S)
6596                addu     $tempreg,$tempreg,$breg
6597                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
6598              With a constant we always use the latter case.
6599
6600              With 64bit address space and no base register and $at usable,
6601              we want
6602                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
6603                lui      $at,<sym>               (BFD_RELOC_HI16_S)
6604                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
6605                dsll32   $tempreg,0
6606                daddu    $tempreg,$at
6607                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
6608              If we have a base register, we want
6609                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
6610                lui      $at,<sym>               (BFD_RELOC_HI16_S)
6611                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
6612                daddu    $at,$breg
6613                dsll32   $tempreg,0
6614                daddu    $tempreg,$at
6615                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
6616
6617              Without $at we can't generate the optimal path for superscalar
6618              processors here since this would require two temporary registers.
6619                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
6620                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
6621                dsll     $tempreg,16
6622                daddiu   $tempreg,<sym>          (BFD_RELOC_HI16_S)
6623                dsll     $tempreg,16
6624                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
6625              If we have a base register, we want
6626                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHEST)
6627                daddiu   $tempreg,<sym>          (BFD_RELOC_MIPS_HIGHER)
6628                dsll     $tempreg,16
6629                daddiu   $tempreg,<sym>          (BFD_RELOC_HI16_S)
6630                dsll     $tempreg,16
6631                daddu    $tempreg,$tempreg,$breg
6632                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_LO16)
6633
6634              For GP relative symbols in 64bit address space we can use
6635              the same sequence as in 32bit address space.  */
6636           if (HAVE_64BIT_SYMBOLS)
6637             {
6638               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
6639                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
6640                 {
6641                   relax_start (offset_expr.X_add_symbol);
6642                   if (breg == 0)
6643                     {
6644                       macro_build (&offset_expr, s, fmt, treg,
6645                                    BFD_RELOC_GPREL16, mips_gp_register);
6646                     }
6647                   else
6648                     {
6649                       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6650                                    tempreg, breg, mips_gp_register);
6651                       macro_build (&offset_expr, s, fmt, treg,
6652                                    BFD_RELOC_GPREL16, tempreg);
6653                     }
6654                   relax_switch ();
6655                 }
6656
6657               if (used_at == 0 && mips_opts.at)
6658                 {
6659                   macro_build (&offset_expr, "lui", "t,u", tempreg,
6660                                BFD_RELOC_MIPS_HIGHEST);
6661                   macro_build (&offset_expr, "lui", "t,u", AT,
6662                                BFD_RELOC_HI16_S);
6663                   macro_build (&offset_expr, "daddiu", "t,r,j", tempreg,
6664                                tempreg, BFD_RELOC_MIPS_HIGHER);
6665                   if (breg != 0)
6666                     macro_build (NULL, "daddu", "d,v,t", AT, AT, breg);
6667                   macro_build (NULL, "dsll32", "d,w,<", tempreg, tempreg, 0);
6668                   macro_build (NULL, "daddu", "d,v,t", tempreg, tempreg, AT);
6669                   macro_build (&offset_expr, s, fmt, treg, BFD_RELOC_LO16,
6670                                tempreg);
6671                   used_at = 1;
6672                 }
6673               else
6674                 {
6675                   macro_build (&offset_expr, "lui", "t,u", tempreg,
6676                                BFD_RELOC_MIPS_HIGHEST);
6677                   macro_build (&offset_expr, "daddiu", "t,r,j", tempreg,
6678                                tempreg, BFD_RELOC_MIPS_HIGHER);
6679                   macro_build (NULL, "dsll", "d,w,<", tempreg, tempreg, 16);
6680                   macro_build (&offset_expr, "daddiu", "t,r,j", tempreg,
6681                                tempreg, BFD_RELOC_HI16_S);
6682                   macro_build (NULL, "dsll", "d,w,<", tempreg, tempreg, 16);
6683                   if (breg != 0)
6684                     macro_build (NULL, "daddu", "d,v,t",
6685                                  tempreg, tempreg, breg);
6686                   macro_build (&offset_expr, s, fmt, treg,
6687                                BFD_RELOC_LO16, tempreg);
6688                 }
6689
6690               if (mips_relax.sequence)
6691                 relax_end ();
6692               break;
6693             }
6694
6695           if (breg == 0)
6696             {
6697               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
6698                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
6699                 {
6700                   relax_start (offset_expr.X_add_symbol);
6701                   macro_build (&offset_expr, s, fmt, treg, BFD_RELOC_GPREL16,
6702                                mips_gp_register);
6703                   relax_switch ();
6704                 }
6705               macro_build_lui (&offset_expr, tempreg);
6706               macro_build (&offset_expr, s, fmt, treg,
6707                            BFD_RELOC_LO16, tempreg);
6708               if (mips_relax.sequence)
6709                 relax_end ();
6710             }
6711           else
6712             {
6713               if ((valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
6714                   && !nopic_need_relax (offset_expr.X_add_symbol, 1))
6715                 {
6716                   relax_start (offset_expr.X_add_symbol);
6717                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6718                                tempreg, breg, mips_gp_register);
6719                   macro_build (&offset_expr, s, fmt, treg,
6720                                BFD_RELOC_GPREL16, tempreg);
6721                   relax_switch ();
6722                 }
6723               macro_build_lui (&offset_expr, tempreg);
6724               macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6725                            tempreg, tempreg, breg);
6726               macro_build (&offset_expr, s, fmt, treg,
6727                            BFD_RELOC_LO16, tempreg);
6728               if (mips_relax.sequence)
6729                 relax_end ();
6730             }
6731         }
6732       else if (!mips_big_got)
6733         {
6734           int lw_reloc_type = (int) BFD_RELOC_MIPS_GOT16;
6735
6736           /* If this is a reference to an external symbol, we want
6737                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
6738                nop
6739                <op>     $treg,0($tempreg)
6740              Otherwise we want
6741                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
6742                nop
6743                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
6744                <op>     $treg,0($tempreg)
6745
6746              For NewABI, we want
6747                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_PAGE)
6748                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_MIPS_GOT_OFST)
6749
6750              If there is a base register, we add it to $tempreg before
6751              the <op>.  If there is a constant, we stick it in the
6752              <op> instruction.  We don't handle constants larger than
6753              16 bits, because we have no way to load the upper 16 bits
6754              (actually, we could handle them for the subset of cases
6755              in which we are not using $at).  */
6756           gas_assert (offset_expr.X_op == O_symbol);
6757           if (HAVE_NEWABI)
6758             {
6759               macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
6760                            BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
6761               if (breg != 0)
6762                 macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6763                              tempreg, tempreg, breg);
6764               macro_build (&offset_expr, s, fmt, treg,
6765                            BFD_RELOC_MIPS_GOT_OFST, tempreg);
6766               break;
6767             }
6768           expr1.X_add_number = offset_expr.X_add_number;
6769           offset_expr.X_add_number = 0;
6770           if (expr1.X_add_number < -0x8000
6771               || expr1.X_add_number >= 0x8000)
6772             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
6773           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
6774                        lw_reloc_type, mips_gp_register);
6775           load_delay_nop ();
6776           relax_start (offset_expr.X_add_symbol);
6777           relax_switch ();
6778           macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j", tempreg,
6779                        tempreg, BFD_RELOC_LO16);
6780           relax_end ();
6781           if (breg != 0)
6782             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6783                          tempreg, tempreg, breg);
6784           macro_build (&expr1, s, fmt, treg, BFD_RELOC_LO16, tempreg);
6785         }
6786       else if (mips_big_got && !HAVE_NEWABI)
6787         {
6788           int gpdelay;
6789
6790           /* If this is a reference to an external symbol, we want
6791                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
6792                addu     $tempreg,$tempreg,$gp
6793                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
6794                <op>     $treg,0($tempreg)
6795              Otherwise we want
6796                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT16)
6797                nop
6798                addiu    $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
6799                <op>     $treg,0($tempreg)
6800              If there is a base register, we add it to $tempreg before
6801              the <op>.  If there is a constant, we stick it in the
6802              <op> instruction.  We don't handle constants larger than
6803              16 bits, because we have no way to load the upper 16 bits
6804              (actually, we could handle them for the subset of cases
6805              in which we are not using $at).  */
6806           gas_assert (offset_expr.X_op == O_symbol);
6807           expr1.X_add_number = offset_expr.X_add_number;
6808           offset_expr.X_add_number = 0;
6809           if (expr1.X_add_number < -0x8000
6810               || expr1.X_add_number >= 0x8000)
6811             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
6812           gpdelay = reg_needs_delay (mips_gp_register);
6813           relax_start (offset_expr.X_add_symbol);
6814           macro_build (&offset_expr, "lui", "t,u", tempreg,
6815                        BFD_RELOC_MIPS_GOT_HI16);
6816           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", tempreg, tempreg,
6817                        mips_gp_register);
6818           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
6819                        BFD_RELOC_MIPS_GOT_LO16, tempreg);
6820           relax_switch ();
6821           if (gpdelay)
6822             macro_build (NULL, "nop", "");
6823           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
6824                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
6825           load_delay_nop ();
6826           macro_build (&offset_expr, ADDRESS_ADDI_INSN, "t,r,j", tempreg,
6827                        tempreg, BFD_RELOC_LO16);
6828           relax_end ();
6829
6830           if (breg != 0)
6831             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6832                          tempreg, tempreg, breg);
6833           macro_build (&expr1, s, fmt, treg, BFD_RELOC_LO16, tempreg);
6834         }
6835       else if (mips_big_got && HAVE_NEWABI)
6836         {
6837           /* If this is a reference to an external symbol, we want
6838                lui      $tempreg,<sym>          (BFD_RELOC_MIPS_GOT_HI16)
6839                add      $tempreg,$tempreg,$gp
6840                lw       $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
6841                <op>     $treg,<ofst>($tempreg)
6842              Otherwise, for local symbols, we want:
6843                lw       $tempreg,<sym>($gp)     (BFD_RELOC_MIPS_GOT_PAGE)
6844                <op>     $treg,<sym>($tempreg)   (BFD_RELOC_MIPS_GOT_OFST)  */
6845           gas_assert (offset_expr.X_op == O_symbol);
6846           expr1.X_add_number = offset_expr.X_add_number;
6847           offset_expr.X_add_number = 0;
6848           if (expr1.X_add_number < -0x8000
6849               || expr1.X_add_number >= 0x8000)
6850             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
6851           relax_start (offset_expr.X_add_symbol);
6852           macro_build (&offset_expr, "lui", "t,u", tempreg,
6853                        BFD_RELOC_MIPS_GOT_HI16);
6854           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", tempreg, tempreg,
6855                        mips_gp_register);
6856           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
6857                        BFD_RELOC_MIPS_GOT_LO16, tempreg);
6858           if (breg != 0)
6859             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6860                          tempreg, tempreg, breg);
6861           macro_build (&expr1, s, fmt, treg, BFD_RELOC_LO16, tempreg);
6862
6863           relax_switch ();
6864           offset_expr.X_add_number = expr1.X_add_number;
6865           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", tempreg,
6866                        BFD_RELOC_MIPS_GOT_PAGE, mips_gp_register);
6867           if (breg != 0)
6868             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
6869                          tempreg, tempreg, breg);
6870           macro_build (&offset_expr, s, fmt, treg,
6871                        BFD_RELOC_MIPS_GOT_OFST, tempreg);
6872           relax_end ();
6873         }
6874       else
6875         abort ();
6876
6877       break;
6878
6879     case M_LI:
6880     case M_LI_S:
6881       load_register (treg, &imm_expr, 0);
6882       break;
6883
6884     case M_DLI:
6885       load_register (treg, &imm_expr, 1);
6886       break;
6887
6888     case M_LI_SS:
6889       if (imm_expr.X_op == O_constant)
6890         {
6891           used_at = 1;
6892           load_register (AT, &imm_expr, 0);
6893           macro_build (NULL, "mtc1", "t,G", AT, treg);
6894           break;
6895         }
6896       else
6897         {
6898           gas_assert (offset_expr.X_op == O_symbol
6899                   && strcmp (segment_name (S_GET_SEGMENT
6900                                            (offset_expr.X_add_symbol)),
6901                              ".lit4") == 0
6902                   && offset_expr.X_add_number == 0);
6903           macro_build (&offset_expr, "lwc1", "T,o(b)", treg,
6904                        BFD_RELOC_MIPS_LITERAL, mips_gp_register);
6905           break;
6906         }
6907
6908     case M_LI_D:
6909       /* Check if we have a constant in IMM_EXPR.  If the GPRs are 64 bits
6910          wide, IMM_EXPR is the entire value.  Otherwise IMM_EXPR is the high
6911          order 32 bits of the value and the low order 32 bits are either
6912          zero or in OFFSET_EXPR.  */
6913       if (imm_expr.X_op == O_constant || imm_expr.X_op == O_big)
6914         {
6915           if (HAVE_64BIT_GPRS)
6916             load_register (treg, &imm_expr, 1);
6917           else
6918             {
6919               int hreg, lreg;
6920
6921               if (target_big_endian)
6922                 {
6923                   hreg = treg;
6924                   lreg = treg + 1;
6925                 }
6926               else
6927                 {
6928                   hreg = treg + 1;
6929                   lreg = treg;
6930                 }
6931
6932               if (hreg <= 31)
6933                 load_register (hreg, &imm_expr, 0);
6934               if (lreg <= 31)
6935                 {
6936                   if (offset_expr.X_op == O_absent)
6937                     move_register (lreg, 0);
6938                   else
6939                     {
6940                       gas_assert (offset_expr.X_op == O_constant);
6941                       load_register (lreg, &offset_expr, 0);
6942                     }
6943                 }
6944             }
6945           break;
6946         }
6947
6948       /* We know that sym is in the .rdata section.  First we get the
6949          upper 16 bits of the address.  */
6950       if (mips_pic == NO_PIC)
6951         {
6952           macro_build_lui (&offset_expr, AT);
6953           used_at = 1;
6954         }
6955       else
6956         {
6957           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", AT,
6958                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
6959           used_at = 1;
6960         }
6961
6962       /* Now we load the register(s).  */
6963       if (HAVE_64BIT_GPRS)
6964         {
6965           used_at = 1;
6966           macro_build (&offset_expr, "ld", "t,o(b)", treg, BFD_RELOC_LO16, AT);
6967         }
6968       else
6969         {
6970           used_at = 1;
6971           macro_build (&offset_expr, "lw", "t,o(b)", treg, BFD_RELOC_LO16, AT);
6972           if (treg != RA)
6973             {
6974               /* FIXME: How in the world do we deal with the possible
6975                  overflow here?  */
6976               offset_expr.X_add_number += 4;
6977               macro_build (&offset_expr, "lw", "t,o(b)",
6978                            treg + 1, BFD_RELOC_LO16, AT);
6979             }
6980         }
6981       break;
6982
6983     case M_LI_DD:
6984       /* Check if we have a constant in IMM_EXPR.  If the FPRs are 64 bits
6985          wide, IMM_EXPR is the entire value and the GPRs are known to be 64
6986          bits wide as well.  Otherwise IMM_EXPR is the high order 32 bits of
6987          the value and the low order 32 bits are either zero or in
6988          OFFSET_EXPR.  */
6989       if (imm_expr.X_op == O_constant || imm_expr.X_op == O_big)
6990         {
6991           used_at = 1;
6992           load_register (AT, &imm_expr, HAVE_64BIT_FPRS);
6993           if (HAVE_64BIT_FPRS)
6994             {
6995               gas_assert (HAVE_64BIT_GPRS);
6996               macro_build (NULL, "dmtc1", "t,S", AT, treg);
6997             }
6998           else
6999             {
7000               macro_build (NULL, "mtc1", "t,G", AT, treg + 1);
7001               if (offset_expr.X_op == O_absent)
7002                 macro_build (NULL, "mtc1", "t,G", 0, treg);
7003               else
7004                 {
7005                   gas_assert (offset_expr.X_op == O_constant);
7006                   load_register (AT, &offset_expr, 0);
7007                   macro_build (NULL, "mtc1", "t,G", AT, treg);
7008                 }
7009             }
7010           break;
7011         }
7012
7013       gas_assert (offset_expr.X_op == O_symbol
7014               && offset_expr.X_add_number == 0);
7015       s = segment_name (S_GET_SEGMENT (offset_expr.X_add_symbol));
7016       if (strcmp (s, ".lit8") == 0)
7017         {
7018           if (mips_opts.isa != ISA_MIPS1)
7019             {
7020               macro_build (&offset_expr, "ldc1", "T,o(b)", treg,
7021                            BFD_RELOC_MIPS_LITERAL, mips_gp_register);
7022               break;
7023             }
7024           breg = mips_gp_register;
7025           r = BFD_RELOC_MIPS_LITERAL;
7026           goto dob;
7027         }
7028       else
7029         {
7030           gas_assert (strcmp (s, RDATA_SECTION_NAME) == 0);
7031           used_at = 1;
7032           if (mips_pic != NO_PIC)
7033             macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", AT,
7034                          BFD_RELOC_MIPS_GOT16, mips_gp_register);
7035           else
7036             {
7037               /* FIXME: This won't work for a 64 bit address.  */
7038               macro_build_lui (&offset_expr, AT);
7039             }
7040
7041           if (mips_opts.isa != ISA_MIPS1)
7042             {
7043               macro_build (&offset_expr, "ldc1", "T,o(b)",
7044                            treg, BFD_RELOC_LO16, AT);
7045               break;
7046             }
7047           breg = AT;
7048           r = BFD_RELOC_LO16;
7049           goto dob;
7050         }
7051
7052     case M_L_DOB:
7053       /* Even on a big endian machine $fn comes before $fn+1.  We have
7054          to adjust when loading from memory.  */
7055       r = BFD_RELOC_LO16;
7056     dob:
7057       gas_assert (mips_opts.isa == ISA_MIPS1);
7058       macro_build (&offset_expr, "lwc1", "T,o(b)",
7059                    target_big_endian ? treg + 1 : treg, r, breg);
7060       /* FIXME: A possible overflow which I don't know how to deal
7061          with.  */
7062       offset_expr.X_add_number += 4;
7063       macro_build (&offset_expr, "lwc1", "T,o(b)",
7064                    target_big_endian ? treg : treg + 1, r, breg);
7065       break;
7066
7067     case M_L_DAB:
7068       /*
7069        * The MIPS assembler seems to check for X_add_number not
7070        * being double aligned and generating:
7071        *        lui     at,%hi(foo+1)
7072        *        addu    at,at,v1
7073        *        addiu   at,at,%lo(foo+1)
7074        *        lwc1    f2,0(at)
7075        *        lwc1    f3,4(at)
7076        * But, the resulting address is the same after relocation so why
7077        * generate the extra instruction?
7078        */
7079       /* Itbl support may require additional care here.  */
7080       coproc = 1;
7081       if (mips_opts.isa != ISA_MIPS1)
7082         {
7083           s = "ldc1";
7084           goto ld;
7085         }
7086
7087       s = "lwc1";
7088       fmt = "T,o(b)";
7089       goto ldd_std;
7090
7091     case M_S_DAB:
7092       if (mips_opts.isa != ISA_MIPS1)
7093         {
7094           s = "sdc1";
7095           goto st;
7096         }
7097
7098       s = "swc1";
7099       fmt = "T,o(b)";
7100       /* Itbl support may require additional care here.  */
7101       coproc = 1;
7102       goto ldd_std;
7103
7104     case M_LD_AB:
7105       if (HAVE_64BIT_GPRS)
7106         {
7107           s = "ld";
7108           goto ld;
7109         }
7110
7111       s = "lw";
7112       fmt = "t,o(b)";
7113       goto ldd_std;
7114
7115     case M_SD_AB:
7116       if (HAVE_64BIT_GPRS)
7117         {
7118           s = "sd";
7119           goto st;
7120         }
7121
7122       s = "sw";
7123       fmt = "t,o(b)";
7124
7125     ldd_std:
7126       if (offset_expr.X_op != O_symbol
7127           && offset_expr.X_op != O_constant)
7128         {
7129           as_bad (_("expression too complex"));
7130           offset_expr.X_op = O_constant;
7131         }
7132
7133       if (HAVE_32BIT_ADDRESSES
7134           && !IS_SEXT_32BIT_NUM (offset_expr.X_add_number))
7135         {
7136           char value [32];
7137
7138           sprintf_vma (value, offset_expr.X_add_number);
7139           as_bad (_("Number (0x%s) larger than 32 bits"), value);
7140         }
7141
7142       /* Even on a big endian machine $fn comes before $fn+1.  We have
7143          to adjust when loading from memory.  We set coproc if we must
7144          load $fn+1 first.  */
7145       /* Itbl support may require additional care here.  */
7146       if (! target_big_endian)
7147         coproc = 0;
7148
7149       if (mips_pic == NO_PIC
7150           || offset_expr.X_op == O_constant)
7151         {
7152           /* If this is a reference to a GP relative symbol, we want
7153                <op>     $treg,<sym>($gp)        (BFD_RELOC_GPREL16)
7154                <op>     $treg+1,<sym>+4($gp)    (BFD_RELOC_GPREL16)
7155              If we have a base register, we use this
7156                addu     $at,$breg,$gp
7157                <op>     $treg,<sym>($at)        (BFD_RELOC_GPREL16)
7158                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_GPREL16)
7159              If this is not a GP relative symbol, we want
7160                lui      $at,<sym>               (BFD_RELOC_HI16_S)
7161                <op>     $treg,<sym>($at)        (BFD_RELOC_LO16)
7162                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_LO16)
7163              If there is a base register, we add it to $at after the
7164              lui instruction.  If there is a constant, we always use
7165              the last case.  */
7166           if (offset_expr.X_op == O_symbol
7167               && (valueT) offset_expr.X_add_number <= MAX_GPREL_OFFSET
7168               && !nopic_need_relax (offset_expr.X_add_symbol, 1))
7169             {
7170               relax_start (offset_expr.X_add_symbol);
7171               if (breg == 0)
7172                 {
7173                   tempreg = mips_gp_register;
7174                 }
7175               else
7176                 {
7177                   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7178                                AT, breg, mips_gp_register);
7179                   tempreg = AT;
7180                   used_at = 1;
7181                 }
7182
7183               /* Itbl support may require additional care here.  */
7184               macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
7185                            BFD_RELOC_GPREL16, tempreg);
7186               offset_expr.X_add_number += 4;
7187
7188               /* Set mips_optimize to 2 to avoid inserting an
7189                  undesired nop.  */
7190               hold_mips_optimize = mips_optimize;
7191               mips_optimize = 2;
7192               /* Itbl support may require additional care here.  */
7193               macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
7194                            BFD_RELOC_GPREL16, tempreg);
7195               mips_optimize = hold_mips_optimize;
7196
7197               relax_switch ();
7198
7199               offset_expr.X_add_number -= 4;
7200             }
7201           used_at = 1;
7202           macro_build_lui (&offset_expr, AT);
7203           if (breg != 0)
7204             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
7205           /* Itbl support may require additional care here.  */
7206           macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
7207                        BFD_RELOC_LO16, AT);
7208           /* FIXME: How do we handle overflow here?  */
7209           offset_expr.X_add_number += 4;
7210           /* Itbl support may require additional care here.  */
7211           macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
7212                        BFD_RELOC_LO16, AT);
7213           if (mips_relax.sequence)
7214             relax_end ();
7215         }
7216       else if (!mips_big_got)
7217         {
7218           /* If this is a reference to an external symbol, we want
7219                lw       $at,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
7220                nop
7221                <op>     $treg,0($at)
7222                <op>     $treg+1,4($at)
7223              Otherwise we want
7224                lw       $at,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
7225                nop
7226                <op>     $treg,<sym>($at)        (BFD_RELOC_LO16)
7227                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_LO16)
7228              If there is a base register we add it to $at before the
7229              lwc1 instructions.  If there is a constant we include it
7230              in the lwc1 instructions.  */
7231           used_at = 1;
7232           expr1.X_add_number = offset_expr.X_add_number;
7233           if (expr1.X_add_number < -0x8000
7234               || expr1.X_add_number >= 0x8000 - 4)
7235             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
7236           load_got_offset (AT, &offset_expr);
7237           load_delay_nop ();
7238           if (breg != 0)
7239             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
7240
7241           /* Set mips_optimize to 2 to avoid inserting an undesired
7242              nop.  */
7243           hold_mips_optimize = mips_optimize;
7244           mips_optimize = 2;
7245
7246           /* Itbl support may require additional care here.  */
7247           relax_start (offset_expr.X_add_symbol);
7248           macro_build (&expr1, s, fmt, coproc ? treg + 1 : treg,
7249                        BFD_RELOC_LO16, AT);
7250           expr1.X_add_number += 4;
7251           macro_build (&expr1, s, fmt, coproc ? treg : treg + 1,
7252                        BFD_RELOC_LO16, AT);
7253           relax_switch ();
7254           macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
7255                        BFD_RELOC_LO16, AT);
7256           offset_expr.X_add_number += 4;
7257           macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
7258                        BFD_RELOC_LO16, AT);
7259           relax_end ();
7260
7261           mips_optimize = hold_mips_optimize;
7262         }
7263       else if (mips_big_got)
7264         {
7265           int gpdelay;
7266
7267           /* If this is a reference to an external symbol, we want
7268                lui      $at,<sym>               (BFD_RELOC_MIPS_GOT_HI16)
7269                addu     $at,$at,$gp
7270                lw       $at,<sym>($at)          (BFD_RELOC_MIPS_GOT_LO16)
7271                nop
7272                <op>     $treg,0($at)
7273                <op>     $treg+1,4($at)
7274              Otherwise we want
7275                lw       $at,<sym>($gp)          (BFD_RELOC_MIPS_GOT16)
7276                nop
7277                <op>     $treg,<sym>($at)        (BFD_RELOC_LO16)
7278                <op>     $treg+1,<sym>+4($at)    (BFD_RELOC_LO16)
7279              If there is a base register we add it to $at before the
7280              lwc1 instructions.  If there is a constant we include it
7281              in the lwc1 instructions.  */
7282           used_at = 1;
7283           expr1.X_add_number = offset_expr.X_add_number;
7284           offset_expr.X_add_number = 0;
7285           if (expr1.X_add_number < -0x8000
7286               || expr1.X_add_number >= 0x8000 - 4)
7287             as_bad (_("PIC code offset overflow (max 16 signed bits)"));
7288           gpdelay = reg_needs_delay (mips_gp_register);
7289           relax_start (offset_expr.X_add_symbol);
7290           macro_build (&offset_expr, "lui", "t,u",
7291                        AT, BFD_RELOC_MIPS_GOT_HI16);
7292           macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t",
7293                        AT, AT, mips_gp_register);
7294           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)",
7295                        AT, BFD_RELOC_MIPS_GOT_LO16, AT);
7296           load_delay_nop ();
7297           if (breg != 0)
7298             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
7299           /* Itbl support may require additional care here.  */
7300           macro_build (&expr1, s, fmt, coproc ? treg + 1 : treg,
7301                        BFD_RELOC_LO16, AT);
7302           expr1.X_add_number += 4;
7303
7304           /* Set mips_optimize to 2 to avoid inserting an undesired
7305              nop.  */
7306           hold_mips_optimize = mips_optimize;
7307           mips_optimize = 2;
7308           /* Itbl support may require additional care here.  */
7309           macro_build (&expr1, s, fmt, coproc ? treg : treg + 1,
7310                        BFD_RELOC_LO16, AT);
7311           mips_optimize = hold_mips_optimize;
7312           expr1.X_add_number -= 4;
7313
7314           relax_switch ();
7315           offset_expr.X_add_number = expr1.X_add_number;
7316           if (gpdelay)
7317             macro_build (NULL, "nop", "");
7318           macro_build (&offset_expr, ADDRESS_LOAD_INSN, "t,o(b)", AT,
7319                        BFD_RELOC_MIPS_GOT16, mips_gp_register);
7320           load_delay_nop ();
7321           if (breg != 0)
7322             macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, breg, AT);
7323           /* Itbl support may require additional care here.  */
7324           macro_build (&offset_expr, s, fmt, coproc ? treg + 1 : treg,
7325                        BFD_RELOC_LO16, AT);
7326           offset_expr.X_add_number += 4;
7327
7328           /* Set mips_optimize to 2 to avoid inserting an undesired
7329              nop.  */
7330           hold_mips_optimize = mips_optimize;
7331           mips_optimize = 2;
7332           /* Itbl support may require additional care here.  */
7333           macro_build (&offset_expr, s, fmt, coproc ? treg : treg + 1,
7334                        BFD_RELOC_LO16, AT);
7335           mips_optimize = hold_mips_optimize;
7336           relax_end ();
7337         }
7338       else
7339         abort ();
7340
7341       break;
7342
7343     case M_LD_OB:
7344       s = HAVE_64BIT_GPRS ? "ld" : "lw";
7345       goto sd_ob;
7346     case M_SD_OB:
7347       s = HAVE_64BIT_GPRS ? "sd" : "sw";
7348     sd_ob:
7349       macro_build (&offset_expr, s, "t,o(b)", treg,
7350                    -1, offset_reloc[0], offset_reloc[1], offset_reloc[2],
7351                    breg);
7352       if (!HAVE_64BIT_GPRS)
7353         {
7354           offset_expr.X_add_number += 4;
7355           macro_build (&offset_expr, s, "t,o(b)", treg + 1,
7356                        -1, offset_reloc[0], offset_reloc[1], offset_reloc[2],
7357                        breg);
7358         }
7359       break;
7360
7361    /* New code added to support COPZ instructions.
7362       This code builds table entries out of the macros in mip_opcodes.
7363       R4000 uses interlocks to handle coproc delays.
7364       Other chips (like the R3000) require nops to be inserted for delays.
7365
7366       FIXME: Currently, we require that the user handle delays.
7367       In order to fill delay slots for non-interlocked chips,
7368       we must have a way to specify delays based on the coprocessor.
7369       Eg. 4 cycles if load coproc reg from memory, 1 if in cache, etc.
7370       What are the side-effects of the cop instruction?
7371       What cache support might we have and what are its effects?
7372       Both coprocessor & memory require delays. how long???
7373       What registers are read/set/modified?
7374
7375       If an itbl is provided to interpret cop instructions,
7376       this knowledge can be encoded in the itbl spec.  */
7377
7378     case M_COP0:
7379       s = "c0";
7380       goto copz;
7381     case M_COP1:
7382       s = "c1";
7383       goto copz;
7384     case M_COP2:
7385       s = "c2";
7386       goto copz;
7387     case M_COP3:
7388       s = "c3";
7389     copz:
7390       if (NO_ISA_COP (mips_opts.arch)
7391           && (ip->insn_mo->pinfo2 & INSN2_M_FP_S) == 0)
7392         {
7393           as_bad (_("opcode not supported on this processor: %s"),
7394                   mips_cpu_info_from_arch (mips_opts.arch)->name);
7395           break;
7396         }
7397
7398       /* For now we just do C (same as Cz).  The parameter will be
7399          stored in insn_opcode by mips_ip.  */
7400       macro_build (NULL, s, "C", ip->insn_opcode);
7401       break;
7402
7403     case M_MOVE:
7404       move_register (dreg, sreg);
7405       break;
7406
7407     case M_DMUL:
7408       dbl = 1;
7409     case M_MUL:
7410       macro_build (NULL, dbl ? "dmultu" : "multu", "s,t", sreg, treg);
7411       macro_build (NULL, "mflo", "d", dreg);
7412       break;
7413
7414     case M_DMUL_I:
7415       dbl = 1;
7416     case M_MUL_I:
7417       /* The MIPS assembler some times generates shifts and adds.  I'm
7418          not trying to be that fancy. GCC should do this for us
7419          anyway.  */
7420       used_at = 1;
7421       load_register (AT, &imm_expr, dbl);
7422       macro_build (NULL, dbl ? "dmult" : "mult", "s,t", sreg, AT);
7423       macro_build (NULL, "mflo", "d", dreg);
7424       break;
7425
7426     case M_DMULO_I:
7427       dbl = 1;
7428     case M_MULO_I:
7429       imm = 1;
7430       goto do_mulo;
7431
7432     case M_DMULO:
7433       dbl = 1;
7434     case M_MULO:
7435     do_mulo:
7436       start_noreorder ();
7437       used_at = 1;
7438       if (imm)
7439         load_register (AT, &imm_expr, dbl);
7440       macro_build (NULL, dbl ? "dmult" : "mult", "s,t", sreg, imm ? AT : treg);
7441       macro_build (NULL, "mflo", "d", dreg);
7442       macro_build (NULL, dbl ? "dsra32" : "sra", "d,w,<", dreg, dreg, RA);
7443       macro_build (NULL, "mfhi", "d", AT);
7444       if (mips_trap)
7445         macro_build (NULL, "tne", "s,t,q", dreg, AT, 6);
7446       else
7447         {
7448           expr1.X_add_number = 8;
7449           macro_build (&expr1, "beq", "s,t,p", dreg, AT);
7450           macro_build (NULL, "nop", "", 0);
7451           macro_build (NULL, "break", "c", 6);
7452         }
7453       end_noreorder ();
7454       macro_build (NULL, "mflo", "d", dreg);
7455       break;
7456
7457     case M_DMULOU_I:
7458       dbl = 1;
7459     case M_MULOU_I:
7460       imm = 1;
7461       goto do_mulou;
7462
7463     case M_DMULOU:
7464       dbl = 1;
7465     case M_MULOU:
7466     do_mulou:
7467       start_noreorder ();
7468       used_at = 1;
7469       if (imm)
7470         load_register (AT, &imm_expr, dbl);
7471       macro_build (NULL, dbl ? "dmultu" : "multu", "s,t",
7472                    sreg, imm ? AT : treg);
7473       macro_build (NULL, "mfhi", "d", AT);
7474       macro_build (NULL, "mflo", "d", dreg);
7475       if (mips_trap)
7476         macro_build (NULL, "tne", "s,t,q", AT, 0, 6);
7477       else
7478         {
7479           expr1.X_add_number = 8;
7480           macro_build (&expr1, "beq", "s,t,p", AT, 0);
7481           macro_build (NULL, "nop", "", 0);
7482           macro_build (NULL, "break", "c", 6);
7483         }
7484       end_noreorder ();
7485       break;
7486
7487     case M_DROL:
7488       if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
7489         {
7490           if (dreg == sreg)
7491             {
7492               tempreg = AT;
7493               used_at = 1;
7494             }
7495           else
7496             {
7497               tempreg = dreg;
7498             }
7499           macro_build (NULL, "dnegu", "d,w", tempreg, treg);
7500           macro_build (NULL, "drorv", "d,t,s", dreg, sreg, tempreg);
7501           break;
7502         }
7503       used_at = 1;
7504       macro_build (NULL, "dsubu", "d,v,t", AT, 0, treg);
7505       macro_build (NULL, "dsrlv", "d,t,s", AT, sreg, AT);
7506       macro_build (NULL, "dsllv", "d,t,s", dreg, sreg, treg);
7507       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7508       break;
7509
7510     case M_ROL:
7511       if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
7512         {
7513           if (dreg == sreg)
7514             {
7515               tempreg = AT;
7516               used_at = 1;
7517             }
7518           else
7519             {
7520               tempreg = dreg;
7521             }
7522           macro_build (NULL, "negu", "d,w", tempreg, treg);
7523           macro_build (NULL, "rorv", "d,t,s", dreg, sreg, tempreg);
7524           break;
7525         }
7526       used_at = 1;
7527       macro_build (NULL, "subu", "d,v,t", AT, 0, treg);
7528       macro_build (NULL, "srlv", "d,t,s", AT, sreg, AT);
7529       macro_build (NULL, "sllv", "d,t,s", dreg, sreg, treg);
7530       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7531       break;
7532
7533     case M_DROL_I:
7534       {
7535         unsigned int rot;
7536         char *l;
7537         char *rr;
7538
7539         if (imm_expr.X_op != O_constant)
7540           as_bad (_("Improper rotate count"));
7541         rot = imm_expr.X_add_number & 0x3f;
7542         if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
7543           {
7544             rot = (64 - rot) & 0x3f;
7545             if (rot >= 32)
7546               macro_build (NULL, "dror32", "d,w,<", dreg, sreg, rot - 32);
7547             else
7548               macro_build (NULL, "dror", "d,w,<", dreg, sreg, rot);
7549             break;
7550           }
7551         if (rot == 0)
7552           {
7553             macro_build (NULL, "dsrl", "d,w,<", dreg, sreg, 0);
7554             break;
7555           }
7556         l = (rot < 0x20) ? "dsll" : "dsll32";
7557         rr = ((0x40 - rot) < 0x20) ? "dsrl" : "dsrl32";
7558         rot &= 0x1f;
7559         used_at = 1;
7560         macro_build (NULL, l, "d,w,<", AT, sreg, rot);
7561         macro_build (NULL, rr, "d,w,<", dreg, sreg, (0x20 - rot) & 0x1f);
7562         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7563       }
7564       break;
7565
7566     case M_ROL_I:
7567       {
7568         unsigned int rot;
7569
7570         if (imm_expr.X_op != O_constant)
7571           as_bad (_("Improper rotate count"));
7572         rot = imm_expr.X_add_number & 0x1f;
7573         if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
7574           {
7575             macro_build (NULL, "ror", "d,w,<", dreg, sreg, (32 - rot) & 0x1f);
7576             break;
7577           }
7578         if (rot == 0)
7579           {
7580             macro_build (NULL, "srl", "d,w,<", dreg, sreg, 0);
7581             break;
7582           }
7583         used_at = 1;
7584         macro_build (NULL, "sll", "d,w,<", AT, sreg, rot);
7585         macro_build (NULL, "srl", "d,w,<", dreg, sreg, (0x20 - rot) & 0x1f);
7586         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7587       }
7588       break;
7589
7590     case M_DROR:
7591       if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
7592         {
7593           macro_build (NULL, "drorv", "d,t,s", dreg, sreg, treg);
7594           break;
7595         }
7596       used_at = 1;
7597       macro_build (NULL, "dsubu", "d,v,t", AT, 0, treg);
7598       macro_build (NULL, "dsllv", "d,t,s", AT, sreg, AT);
7599       macro_build (NULL, "dsrlv", "d,t,s", dreg, sreg, treg);
7600       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7601       break;
7602
7603     case M_ROR:
7604       if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
7605         {
7606           macro_build (NULL, "rorv", "d,t,s", dreg, sreg, treg);
7607           break;
7608         }
7609       used_at = 1;
7610       macro_build (NULL, "subu", "d,v,t", AT, 0, treg);
7611       macro_build (NULL, "sllv", "d,t,s", AT, sreg, AT);
7612       macro_build (NULL, "srlv", "d,t,s", dreg, sreg, treg);
7613       macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7614       break;
7615
7616     case M_DROR_I:
7617       {
7618         unsigned int rot;
7619         char *l;
7620         char *rr;
7621
7622         if (imm_expr.X_op != O_constant)
7623           as_bad (_("Improper rotate count"));
7624         rot = imm_expr.X_add_number & 0x3f;
7625         if (ISA_HAS_DROR (mips_opts.isa) || CPU_HAS_DROR (mips_opts.arch))
7626           {
7627             if (rot >= 32)
7628               macro_build (NULL, "dror32", "d,w,<", dreg, sreg, rot - 32);
7629             else
7630               macro_build (NULL, "dror", "d,w,<", dreg, sreg, rot);
7631             break;
7632           }
7633         if (rot == 0)
7634           {
7635             macro_build (NULL, "dsrl", "d,w,<", dreg, sreg, 0);
7636             break;
7637           }
7638         rr = (rot < 0x20) ? "dsrl" : "dsrl32";
7639         l = ((0x40 - rot) < 0x20) ? "dsll" : "dsll32";
7640         rot &= 0x1f;
7641         used_at = 1;
7642         macro_build (NULL, rr, "d,w,<", AT, sreg, rot);
7643         macro_build (NULL, l, "d,w,<", dreg, sreg, (0x20 - rot) & 0x1f);
7644         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7645       }
7646       break;
7647
7648     case M_ROR_I:
7649       {
7650         unsigned int rot;
7651
7652         if (imm_expr.X_op != O_constant)
7653           as_bad (_("Improper rotate count"));
7654         rot = imm_expr.X_add_number & 0x1f;
7655         if (ISA_HAS_ROR (mips_opts.isa) || CPU_HAS_ROR (mips_opts.arch))
7656           {
7657             macro_build (NULL, "ror", "d,w,<", dreg, sreg, rot);
7658             break;
7659           }
7660         if (rot == 0)
7661           {
7662             macro_build (NULL, "srl", "d,w,<", dreg, sreg, 0);
7663             break;
7664           }
7665         used_at = 1;
7666         macro_build (NULL, "srl", "d,w,<", AT, sreg, rot);
7667         macro_build (NULL, "sll", "d,w,<", dreg, sreg, (0x20 - rot) & 0x1f);
7668         macro_build (NULL, "or", "d,v,t", dreg, dreg, AT);
7669       }
7670       break;
7671
7672     case M_S_DOB:
7673       gas_assert (mips_opts.isa == ISA_MIPS1);
7674       /* Even on a big endian machine $fn comes before $fn+1.  We have
7675          to adjust when storing to memory.  */
7676       macro_build (&offset_expr, "swc1", "T,o(b)",
7677                    target_big_endian ? treg + 1 : treg, BFD_RELOC_LO16, breg);
7678       offset_expr.X_add_number += 4;
7679       macro_build (&offset_expr, "swc1", "T,o(b)",
7680                    target_big_endian ? treg : treg + 1, BFD_RELOC_LO16, breg);
7681       break;
7682
7683     case M_SEQ:
7684       if (sreg == 0)
7685         macro_build (&expr1, "sltiu", "t,r,j", dreg, treg, BFD_RELOC_LO16);
7686       else if (treg == 0)
7687         macro_build (&expr1, "sltiu", "t,r,j", dreg, sreg, BFD_RELOC_LO16);
7688       else
7689         {
7690           macro_build (NULL, "xor", "d,v,t", dreg, sreg, treg);
7691           macro_build (&expr1, "sltiu", "t,r,j", dreg, dreg, BFD_RELOC_LO16);
7692         }
7693       break;
7694
7695     case M_SEQ_I:
7696       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
7697         {
7698           macro_build (&expr1, "sltiu", "t,r,j", dreg, sreg, BFD_RELOC_LO16);
7699           break;
7700         }
7701       if (sreg == 0)
7702         {
7703           as_warn (_("Instruction %s: result is always false"),
7704                    ip->insn_mo->name);
7705           move_register (dreg, 0);
7706           break;
7707         }
7708       if (CPU_HAS_SEQ (mips_opts.arch)
7709           && -512 <= imm_expr.X_add_number
7710           && imm_expr.X_add_number < 512)
7711         {
7712           macro_build (NULL, "seqi", "t,r,+Q", dreg, sreg,
7713                        (int) imm_expr.X_add_number);
7714           break;
7715         }
7716       if (imm_expr.X_op == O_constant
7717           && imm_expr.X_add_number >= 0
7718           && imm_expr.X_add_number < 0x10000)
7719         {
7720           macro_build (&imm_expr, "xori", "t,r,i", dreg, sreg, BFD_RELOC_LO16);
7721         }
7722       else if (imm_expr.X_op == O_constant
7723                && imm_expr.X_add_number > -0x8000
7724                && imm_expr.X_add_number < 0)
7725         {
7726           imm_expr.X_add_number = -imm_expr.X_add_number;
7727           macro_build (&imm_expr, HAVE_32BIT_GPRS ? "addiu" : "daddiu",
7728                        "t,r,j", dreg, sreg, BFD_RELOC_LO16);
7729         }
7730       else if (CPU_HAS_SEQ (mips_opts.arch))
7731         {
7732           used_at = 1;
7733           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7734           macro_build (NULL, "seq", "d,v,t", dreg, sreg, AT);
7735           break;
7736         }
7737       else
7738         {
7739           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7740           macro_build (NULL, "xor", "d,v,t", dreg, sreg, AT);
7741           used_at = 1;
7742         }
7743       macro_build (&expr1, "sltiu", "t,r,j", dreg, dreg, BFD_RELOC_LO16);
7744       break;
7745
7746     case M_SGE:         /* sreg >= treg <==> not (sreg < treg) */
7747       s = "slt";
7748       goto sge;
7749     case M_SGEU:
7750       s = "sltu";
7751     sge:
7752       macro_build (NULL, s, "d,v,t", dreg, sreg, treg);
7753       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
7754       break;
7755
7756     case M_SGE_I:               /* sreg >= I <==> not (sreg < I) */
7757     case M_SGEU_I:
7758       if (imm_expr.X_op == O_constant
7759           && imm_expr.X_add_number >= -0x8000
7760           && imm_expr.X_add_number < 0x8000)
7761         {
7762           macro_build (&imm_expr, mask == M_SGE_I ? "slti" : "sltiu", "t,r,j",
7763                        dreg, sreg, BFD_RELOC_LO16);
7764         }
7765       else
7766         {
7767           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7768           macro_build (NULL, mask == M_SGE_I ? "slt" : "sltu", "d,v,t",
7769                        dreg, sreg, AT);
7770           used_at = 1;
7771         }
7772       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
7773       break;
7774
7775     case M_SGT:         /* sreg > treg  <==>  treg < sreg */
7776       s = "slt";
7777       goto sgt;
7778     case M_SGTU:
7779       s = "sltu";
7780     sgt:
7781       macro_build (NULL, s, "d,v,t", dreg, treg, sreg);
7782       break;
7783
7784     case M_SGT_I:               /* sreg > I  <==>  I < sreg */
7785       s = "slt";
7786       goto sgti;
7787     case M_SGTU_I:
7788       s = "sltu";
7789     sgti:
7790       used_at = 1;
7791       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7792       macro_build (NULL, s, "d,v,t", dreg, AT, sreg);
7793       break;
7794
7795     case M_SLE: /* sreg <= treg  <==>  treg >= sreg  <==>  not (treg < sreg) */
7796       s = "slt";
7797       goto sle;
7798     case M_SLEU:
7799       s = "sltu";
7800     sle:
7801       macro_build (NULL, s, "d,v,t", dreg, treg, sreg);
7802       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
7803       break;
7804
7805     case M_SLE_I:       /* sreg <= I <==> I >= sreg <==> not (I < sreg) */
7806       s = "slt";
7807       goto slei;
7808     case M_SLEU_I:
7809       s = "sltu";
7810     slei:
7811       used_at = 1;
7812       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7813       macro_build (NULL, s, "d,v,t", dreg, AT, sreg);
7814       macro_build (&expr1, "xori", "t,r,i", dreg, dreg, BFD_RELOC_LO16);
7815       break;
7816
7817     case M_SLT_I:
7818       if (imm_expr.X_op == O_constant
7819           && imm_expr.X_add_number >= -0x8000
7820           && imm_expr.X_add_number < 0x8000)
7821         {
7822           macro_build (&imm_expr, "slti", "t,r,j", dreg, sreg, BFD_RELOC_LO16);
7823           break;
7824         }
7825       used_at = 1;
7826       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7827       macro_build (NULL, "slt", "d,v,t", dreg, sreg, AT);
7828       break;
7829
7830     case M_SLTU_I:
7831       if (imm_expr.X_op == O_constant
7832           && imm_expr.X_add_number >= -0x8000
7833           && imm_expr.X_add_number < 0x8000)
7834         {
7835           macro_build (&imm_expr, "sltiu", "t,r,j", dreg, sreg,
7836                        BFD_RELOC_LO16);
7837           break;
7838         }
7839       used_at = 1;
7840       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7841       macro_build (NULL, "sltu", "d,v,t", dreg, sreg, AT);
7842       break;
7843
7844     case M_SNE:
7845       if (sreg == 0)
7846         macro_build (NULL, "sltu", "d,v,t", dreg, 0, treg);
7847       else if (treg == 0)
7848         macro_build (NULL, "sltu", "d,v,t", dreg, 0, sreg);
7849       else
7850         {
7851           macro_build (NULL, "xor", "d,v,t", dreg, sreg, treg);
7852           macro_build (NULL, "sltu", "d,v,t", dreg, 0, dreg);
7853         }
7854       break;
7855
7856     case M_SNE_I:
7857       if (imm_expr.X_op == O_constant && imm_expr.X_add_number == 0)
7858         {
7859           macro_build (NULL, "sltu", "d,v,t", dreg, 0, sreg);
7860           break;
7861         }
7862       if (sreg == 0)
7863         {
7864           as_warn (_("Instruction %s: result is always true"),
7865                    ip->insn_mo->name);
7866           macro_build (&expr1, HAVE_32BIT_GPRS ? "addiu" : "daddiu", "t,r,j",
7867                        dreg, 0, BFD_RELOC_LO16);
7868           break;
7869         }
7870       if (CPU_HAS_SEQ (mips_opts.arch)
7871           && -512 <= imm_expr.X_add_number
7872           && imm_expr.X_add_number < 512)
7873         {
7874           macro_build (NULL, "snei", "t,r,+Q", dreg, sreg,
7875                        (int) imm_expr.X_add_number);
7876           break;
7877         }
7878       if (imm_expr.X_op == O_constant
7879           && imm_expr.X_add_number >= 0
7880           && imm_expr.X_add_number < 0x10000)
7881         {
7882           macro_build (&imm_expr, "xori", "t,r,i", dreg, sreg, BFD_RELOC_LO16);
7883         }
7884       else if (imm_expr.X_op == O_constant
7885                && imm_expr.X_add_number > -0x8000
7886                && imm_expr.X_add_number < 0)
7887         {
7888           imm_expr.X_add_number = -imm_expr.X_add_number;
7889           macro_build (&imm_expr, HAVE_32BIT_GPRS ? "addiu" : "daddiu",
7890                        "t,r,j", dreg, sreg, BFD_RELOC_LO16);
7891         }
7892       else if (CPU_HAS_SEQ (mips_opts.arch))
7893         {
7894           used_at = 1;
7895           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7896           macro_build (NULL, "sne", "d,v,t", dreg, sreg, AT);
7897           break;
7898         }
7899       else
7900         {
7901           load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7902           macro_build (NULL, "xor", "d,v,t", dreg, sreg, AT);
7903           used_at = 1;
7904         }
7905       macro_build (NULL, "sltu", "d,v,t", dreg, 0, dreg);
7906       break;
7907
7908     case M_DSUB_I:
7909       dbl = 1;
7910     case M_SUB_I:
7911       if (imm_expr.X_op == O_constant
7912           && imm_expr.X_add_number > -0x8000
7913           && imm_expr.X_add_number <= 0x8000)
7914         {
7915           imm_expr.X_add_number = -imm_expr.X_add_number;
7916           macro_build (&imm_expr, dbl ? "daddi" : "addi", "t,r,j",
7917                        dreg, sreg, BFD_RELOC_LO16);
7918           break;
7919         }
7920       used_at = 1;
7921       load_register (AT, &imm_expr, dbl);
7922       macro_build (NULL, dbl ? "dsub" : "sub", "d,v,t", dreg, sreg, AT);
7923       break;
7924
7925     case M_DSUBU_I:
7926       dbl = 1;
7927     case M_SUBU_I:
7928       if (imm_expr.X_op == O_constant
7929           && imm_expr.X_add_number > -0x8000
7930           && imm_expr.X_add_number <= 0x8000)
7931         {
7932           imm_expr.X_add_number = -imm_expr.X_add_number;
7933           macro_build (&imm_expr, dbl ? "daddiu" : "addiu", "t,r,j",
7934                        dreg, sreg, BFD_RELOC_LO16);
7935           break;
7936         }
7937       used_at = 1;
7938       load_register (AT, &imm_expr, dbl);
7939       macro_build (NULL, dbl ? "dsubu" : "subu", "d,v,t", dreg, sreg, AT);
7940       break;
7941
7942     case M_TEQ_I:
7943       s = "teq";
7944       goto trap;
7945     case M_TGE_I:
7946       s = "tge";
7947       goto trap;
7948     case M_TGEU_I:
7949       s = "tgeu";
7950       goto trap;
7951     case M_TLT_I:
7952       s = "tlt";
7953       goto trap;
7954     case M_TLTU_I:
7955       s = "tltu";
7956       goto trap;
7957     case M_TNE_I:
7958       s = "tne";
7959     trap:
7960       used_at = 1;
7961       load_register (AT, &imm_expr, HAVE_64BIT_GPRS);
7962       macro_build (NULL, s, "s,t", sreg, AT);
7963       break;
7964
7965     case M_TRUNCWS:
7966     case M_TRUNCWD:
7967       gas_assert (mips_opts.isa == ISA_MIPS1);
7968       used_at = 1;
7969       sreg = (ip->insn_opcode >> 11) & 0x1f;    /* floating reg */
7970       dreg = (ip->insn_opcode >> 06) & 0x1f;    /* floating reg */
7971
7972       /*
7973        * Is the double cfc1 instruction a bug in the mips assembler;
7974        * or is there a reason for it?
7975        */
7976       start_noreorder ();
7977       macro_build (NULL, "cfc1", "t,G", treg, RA);
7978       macro_build (NULL, "cfc1", "t,G", treg, RA);
7979       macro_build (NULL, "nop", "");
7980       expr1.X_add_number = 3;
7981       macro_build (&expr1, "ori", "t,r,i", AT, treg, BFD_RELOC_LO16);
7982       expr1.X_add_number = 2;
7983       macro_build (&expr1, "xori", "t,r,i", AT, AT, BFD_RELOC_LO16);
7984       macro_build (NULL, "ctc1", "t,G", AT, RA);
7985       macro_build (NULL, "nop", "");
7986       macro_build (NULL, mask == M_TRUNCWD ? "cvt.w.d" : "cvt.w.s", "D,S",
7987                    dreg, sreg);
7988       macro_build (NULL, "ctc1", "t,G", treg, RA);
7989       macro_build (NULL, "nop", "");
7990       end_noreorder ();
7991       break;
7992
7993     case M_ULH:
7994       s = "lb";
7995       goto ulh;
7996     case M_ULHU:
7997       s = "lbu";
7998     ulh:
7999       used_at = 1;
8000       if (offset_expr.X_add_number >= 0x7fff)
8001         as_bad (_("operand overflow"));
8002       if (! target_big_endian)
8003         ++offset_expr.X_add_number;
8004       macro_build (&offset_expr, s, "t,o(b)", AT, BFD_RELOC_LO16, breg);
8005       if (! target_big_endian)
8006         --offset_expr.X_add_number;
8007       else
8008         ++offset_expr.X_add_number;
8009       macro_build (&offset_expr, "lbu", "t,o(b)", treg, BFD_RELOC_LO16, breg);
8010       macro_build (NULL, "sll", "d,w,<", AT, AT, 8);
8011       macro_build (NULL, "or", "d,v,t", treg, treg, AT);
8012       break;
8013
8014     case M_ULD:
8015       s = "ldl";
8016       s2 = "ldr";
8017       off = 7;
8018       goto ulw;
8019     case M_ULW:
8020       s = "lwl";
8021       s2 = "lwr";
8022       off = 3;
8023     ulw:
8024       if (offset_expr.X_add_number >= 0x8000 - off)
8025         as_bad (_("operand overflow"));
8026       if (treg != breg)
8027         tempreg = treg;
8028       else
8029         {
8030           used_at = 1;
8031           tempreg = AT;
8032         }
8033       if (! target_big_endian)
8034         offset_expr.X_add_number += off;
8035       macro_build (&offset_expr, s, "t,o(b)", tempreg, BFD_RELOC_LO16, breg);
8036       if (! target_big_endian)
8037         offset_expr.X_add_number -= off;
8038       else
8039         offset_expr.X_add_number += off;
8040       macro_build (&offset_expr, s2, "t,o(b)", tempreg, BFD_RELOC_LO16, breg);
8041
8042       /* If necessary, move the result in tempreg the final destination.  */
8043       if (treg == tempreg)
8044         break;
8045       /* Protect second load's delay slot.  */
8046       load_delay_nop ();
8047       move_register (treg, tempreg);
8048       break;
8049
8050     case M_ULD_A:
8051       s = "ldl";
8052       s2 = "ldr";
8053       off = 7;
8054       goto ulwa;
8055     case M_ULW_A:
8056       s = "lwl";
8057       s2 = "lwr";
8058       off = 3;
8059     ulwa:
8060       used_at = 1;
8061       load_address (AT, &offset_expr, &used_at);
8062       if (breg != 0)
8063         macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, AT, breg);
8064       if (! target_big_endian)
8065         expr1.X_add_number = off;
8066       else
8067         expr1.X_add_number = 0;
8068       macro_build (&expr1, s, "t,o(b)", treg, BFD_RELOC_LO16, AT);
8069       if (! target_big_endian)
8070         expr1.X_add_number = 0;
8071       else
8072         expr1.X_add_number = off;
8073       macro_build (&expr1, s2, "t,o(b)", treg, BFD_RELOC_LO16, AT);
8074       break;
8075
8076     case M_ULH_A:
8077     case M_ULHU_A:
8078       used_at = 1;
8079       load_address (AT, &offset_expr, &used_at);
8080       if (breg != 0)
8081         macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, AT, breg);
8082       if (target_big_endian)
8083         expr1.X_add_number = 0;
8084       macro_build (&expr1, mask == M_ULH_A ? "lb" : "lbu", "t,o(b)",
8085                    treg, BFD_RELOC_LO16, AT);
8086       if (target_big_endian)
8087         expr1.X_add_number = 1;
8088       else
8089         expr1.X_add_number = 0;
8090       macro_build (&expr1, "lbu", "t,o(b)", AT, BFD_RELOC_LO16, AT);
8091       macro_build (NULL, "sll", "d,w,<", treg, treg, 8);
8092       macro_build (NULL, "or", "d,v,t", treg, treg, AT);
8093       break;
8094
8095     case M_USH:
8096       used_at = 1;
8097       if (offset_expr.X_add_number >= 0x7fff)
8098         as_bad (_("operand overflow"));
8099       if (target_big_endian)
8100         ++offset_expr.X_add_number;
8101       macro_build (&offset_expr, "sb", "t,o(b)", treg, BFD_RELOC_LO16, breg);
8102       macro_build (NULL, "srl", "d,w,<", AT, treg, 8);
8103       if (target_big_endian)
8104         --offset_expr.X_add_number;
8105       else
8106         ++offset_expr.X_add_number;
8107       macro_build (&offset_expr, "sb", "t,o(b)", AT, BFD_RELOC_LO16, breg);
8108       break;
8109
8110     case M_USD:
8111       s = "sdl";
8112       s2 = "sdr";
8113       off = 7;
8114       goto usw;
8115     case M_USW:
8116       s = "swl";
8117       s2 = "swr";
8118       off = 3;
8119     usw:
8120       if (offset_expr.X_add_number >= 0x8000 - off)
8121         as_bad (_("operand overflow"));
8122       if (! target_big_endian)
8123         offset_expr.X_add_number += off;
8124       macro_build (&offset_expr, s, "t,o(b)", treg, BFD_RELOC_LO16, breg);
8125       if (! target_big_endian)
8126         offset_expr.X_add_number -= off;
8127       else
8128         offset_expr.X_add_number += off;
8129       macro_build (&offset_expr, s2, "t,o(b)", treg, BFD_RELOC_LO16, breg);
8130       break;
8131
8132     case M_USD_A:
8133       s = "sdl";
8134       s2 = "sdr";
8135       off = 7;
8136       goto uswa;
8137     case M_USW_A:
8138       s = "swl";
8139       s2 = "swr";
8140       off = 3;
8141     uswa:
8142       used_at = 1;
8143       load_address (AT, &offset_expr, &used_at);
8144       if (breg != 0)
8145         macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, AT, breg);
8146       if (! target_big_endian)
8147         expr1.X_add_number = off;
8148       else
8149         expr1.X_add_number = 0;
8150       macro_build (&expr1, s, "t,o(b)", treg, BFD_RELOC_LO16, AT);
8151       if (! target_big_endian)
8152         expr1.X_add_number = 0;
8153       else
8154         expr1.X_add_number = off;
8155       macro_build (&expr1, s2, "t,o(b)", treg, BFD_RELOC_LO16, AT);
8156       break;
8157
8158     case M_USH_A:
8159       used_at = 1;
8160       load_address (AT, &offset_expr, &used_at);
8161       if (breg != 0)
8162         macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", AT, AT, breg);
8163       if (! target_big_endian)
8164         expr1.X_add_number = 0;
8165       macro_build (&expr1, "sb", "t,o(b)", treg, BFD_RELOC_LO16, AT);
8166       macro_build (NULL, "srl", "d,w,<", treg, treg, 8);
8167       if (! target_big_endian)
8168         expr1.X_add_number = 1;
8169       else
8170         expr1.X_add_number = 0;
8171       macro_build (&expr1, "sb", "t,o(b)", treg, BFD_RELOC_LO16, AT);
8172       if (! target_big_endian)
8173         expr1.X_add_number = 0;
8174       else
8175         expr1.X_add_number = 1;
8176       macro_build (&expr1, "lbu", "t,o(b)", AT, BFD_RELOC_LO16, AT);
8177       macro_build (NULL, "sll", "d,w,<", treg, treg, 8);
8178       macro_build (NULL, "or", "d,v,t", treg, treg, AT);
8179       break;
8180
8181     default:
8182       /* FIXME: Check if this is one of the itbl macros, since they
8183          are added dynamically.  */
8184       as_bad (_("Macro %s not implemented yet"), ip->insn_mo->name);
8185       break;
8186     }
8187   if (!mips_opts.at && used_at)
8188     as_bad (_("Macro used $at after \".set noat\""));
8189 }
8190
8191 /* Implement macros in mips16 mode.  */
8192
8193 static void
8194 mips16_macro (struct mips_cl_insn *ip)
8195 {
8196   int mask;
8197   int xreg, yreg, zreg, tmp;
8198   expressionS expr1;
8199   int dbl;
8200   const char *s, *s2, *s3;
8201
8202   mask = ip->insn_mo->mask;
8203
8204   xreg = MIPS16_EXTRACT_OPERAND (RX, *ip);
8205   yreg = MIPS16_EXTRACT_OPERAND (RY, *ip);
8206   zreg = MIPS16_EXTRACT_OPERAND (RZ, *ip);
8207
8208   expr1.X_op = O_constant;
8209   expr1.X_op_symbol = NULL;
8210   expr1.X_add_symbol = NULL;
8211   expr1.X_add_number = 1;
8212
8213   dbl = 0;
8214
8215   switch (mask)
8216     {
8217     default:
8218       internalError ();
8219
8220     case M_DDIV_3:
8221       dbl = 1;
8222     case M_DIV_3:
8223       s = "mflo";
8224       goto do_div3;
8225     case M_DREM_3:
8226       dbl = 1;
8227     case M_REM_3:
8228       s = "mfhi";
8229     do_div3:
8230       start_noreorder ();
8231       macro_build (NULL, dbl ? "ddiv" : "div", "0,x,y", xreg, yreg);
8232       expr1.X_add_number = 2;
8233       macro_build (&expr1, "bnez", "x,p", yreg);
8234       macro_build (NULL, "break", "6", 7);
8235
8236       /* FIXME: The normal code checks for of -1 / -0x80000000 here,
8237          since that causes an overflow.  We should do that as well,
8238          but I don't see how to do the comparisons without a temporary
8239          register.  */
8240       end_noreorder ();
8241       macro_build (NULL, s, "x", zreg);
8242       break;
8243
8244     case M_DIVU_3:
8245       s = "divu";
8246       s2 = "mflo";
8247       goto do_divu3;
8248     case M_REMU_3:
8249       s = "divu";
8250       s2 = "mfhi";
8251       goto do_divu3;
8252     case M_DDIVU_3:
8253       s = "ddivu";
8254       s2 = "mflo";
8255       goto do_divu3;
8256     case M_DREMU_3:
8257       s = "ddivu";
8258       s2 = "mfhi";
8259     do_divu3:
8260       start_noreorder ();
8261       macro_build (NULL, s, "0,x,y", xreg, yreg);
8262       expr1.X_add_number = 2;
8263       macro_build (&expr1, "bnez", "x,p", yreg);
8264       macro_build (NULL, "break", "6", 7);
8265       end_noreorder ();
8266       macro_build (NULL, s2, "x", zreg);
8267       break;
8268
8269     case M_DMUL:
8270       dbl = 1;
8271     case M_MUL:
8272       macro_build (NULL, dbl ? "dmultu" : "multu", "x,y", xreg, yreg);
8273       macro_build (NULL, "mflo", "x", zreg);
8274       break;
8275
8276     case M_DSUBU_I:
8277       dbl = 1;
8278       goto do_subu;
8279     case M_SUBU_I:
8280     do_subu:
8281       if (imm_expr.X_op != O_constant)
8282         as_bad (_("Unsupported large constant"));
8283       imm_expr.X_add_number = -imm_expr.X_add_number;
8284       macro_build (&imm_expr, dbl ? "daddiu" : "addiu", "y,x,4", yreg, xreg);
8285       break;
8286
8287     case M_SUBU_I_2:
8288       if (imm_expr.X_op != O_constant)
8289         as_bad (_("Unsupported large constant"));
8290       imm_expr.X_add_number = -imm_expr.X_add_number;
8291       macro_build (&imm_expr, "addiu", "x,k", xreg);
8292       break;
8293
8294     case M_DSUBU_I_2:
8295       if (imm_expr.X_op != O_constant)
8296         as_bad (_("Unsupported large constant"));
8297       imm_expr.X_add_number = -imm_expr.X_add_number;
8298       macro_build (&imm_expr, "daddiu", "y,j", yreg);
8299       break;
8300
8301     case M_BEQ:
8302       s = "cmp";
8303       s2 = "bteqz";
8304       goto do_branch;
8305     case M_BNE:
8306       s = "cmp";
8307       s2 = "btnez";
8308       goto do_branch;
8309     case M_BLT:
8310       s = "slt";
8311       s2 = "btnez";
8312       goto do_branch;
8313     case M_BLTU:
8314       s = "sltu";
8315       s2 = "btnez";
8316       goto do_branch;
8317     case M_BLE:
8318       s = "slt";
8319       s2 = "bteqz";
8320       goto do_reverse_branch;
8321     case M_BLEU:
8322       s = "sltu";
8323       s2 = "bteqz";
8324       goto do_reverse_branch;
8325     case M_BGE:
8326       s = "slt";
8327       s2 = "bteqz";
8328       goto do_branch;
8329     case M_BGEU:
8330       s = "sltu";
8331       s2 = "bteqz";
8332       goto do_branch;
8333     case M_BGT:
8334       s = "slt";
8335       s2 = "btnez";
8336       goto do_reverse_branch;
8337     case M_BGTU:
8338       s = "sltu";
8339       s2 = "btnez";
8340
8341     do_reverse_branch:
8342       tmp = xreg;
8343       xreg = yreg;
8344       yreg = tmp;
8345
8346     do_branch:
8347       macro_build (NULL, s, "x,y", xreg, yreg);
8348       macro_build (&offset_expr, s2, "p");
8349       break;
8350
8351     case M_BEQ_I:
8352       s = "cmpi";
8353       s2 = "bteqz";
8354       s3 = "x,U";
8355       goto do_branch_i;
8356     case M_BNE_I:
8357       s = "cmpi";
8358       s2 = "btnez";
8359       s3 = "x,U";
8360       goto do_branch_i;
8361     case M_BLT_I:
8362       s = "slti";
8363       s2 = "btnez";
8364       s3 = "x,8";
8365       goto do_branch_i;
8366     case M_BLTU_I:
8367       s = "sltiu";
8368       s2 = "btnez";
8369       s3 = "x,8";
8370       goto do_branch_i;
8371     case M_BLE_I:
8372       s = "slti";
8373       s2 = "btnez";
8374       s3 = "x,8";
8375       goto do_addone_branch_i;
8376     case M_BLEU_I:
8377       s = "sltiu";
8378       s2 = "btnez";
8379       s3 = "x,8";
8380       goto do_addone_branch_i;
8381     case M_BGE_I:
8382       s = "slti";
8383       s2 = "bteqz";
8384       s3 = "x,8";
8385       goto do_branch_i;
8386     case M_BGEU_I:
8387       s = "sltiu";
8388       s2 = "bteqz";
8389       s3 = "x,8";
8390       goto do_branch_i;
8391     case M_BGT_I:
8392       s = "slti";
8393       s2 = "bteqz";
8394       s3 = "x,8";
8395       goto do_addone_branch_i;
8396     case M_BGTU_I:
8397       s = "sltiu";
8398       s2 = "bteqz";
8399       s3 = "x,8";
8400
8401     do_addone_branch_i:
8402       if (imm_expr.X_op != O_constant)
8403         as_bad (_("Unsupported large constant"));
8404       ++imm_expr.X_add_number;
8405
8406     do_branch_i:
8407       macro_build (&imm_expr, s, s3, xreg);
8408       macro_build (&offset_expr, s2, "p");
8409       break;
8410
8411     case M_ABS:
8412       expr1.X_add_number = 0;
8413       macro_build (&expr1, "slti", "x,8", yreg);
8414       if (xreg != yreg)
8415         move_register (xreg, yreg);
8416       expr1.X_add_number = 2;
8417       macro_build (&expr1, "bteqz", "p");
8418       macro_build (NULL, "neg", "x,w", xreg, xreg);
8419     }
8420 }
8421
8422 /* For consistency checking, verify that all bits are specified either
8423    by the match/mask part of the instruction definition, or by the
8424    operand list.  */
8425 static int
8426 validate_mips_insn (const struct mips_opcode *opc)
8427 {
8428   const char *p = opc->args;
8429   char c;
8430   unsigned long used_bits = opc->mask;
8431
8432   if ((used_bits & opc->match) != opc->match)
8433     {
8434       as_bad (_("internal: bad mips opcode (mask error): %s %s"),
8435               opc->name, opc->args);
8436       return 0;
8437     }
8438 #define USE_BITS(mask,shift)    (used_bits |= ((mask) << (shift)))
8439   while (*p)
8440     switch (c = *p++)
8441       {
8442       case ',': break;
8443       case '(': break;
8444       case ')': break;
8445       case '+':
8446         switch (c = *p++)
8447           {
8448           case '1': USE_BITS (OP_MASK_UDI1,     OP_SH_UDI1);    break;
8449           case '2': USE_BITS (OP_MASK_UDI2,     OP_SH_UDI2);    break;
8450           case '3': USE_BITS (OP_MASK_UDI3,     OP_SH_UDI3);    break;
8451           case '4': USE_BITS (OP_MASK_UDI4,     OP_SH_UDI4);    break;
8452           case 'A': USE_BITS (OP_MASK_SHAMT,    OP_SH_SHAMT);   break;
8453           case 'B': USE_BITS (OP_MASK_INSMSB,   OP_SH_INSMSB);  break;
8454           case 'C': USE_BITS (OP_MASK_EXTMSBD,  OP_SH_EXTMSBD); break;
8455           case 'D': USE_BITS (OP_MASK_RD,       OP_SH_RD);
8456                     USE_BITS (OP_MASK_SEL,      OP_SH_SEL);     break;
8457           case 'E': USE_BITS (OP_MASK_SHAMT,    OP_SH_SHAMT);   break;
8458           case 'F': USE_BITS (OP_MASK_INSMSB,   OP_SH_INSMSB);  break;
8459           case 'G': USE_BITS (OP_MASK_EXTMSBD,  OP_SH_EXTMSBD); break;
8460           case 'H': USE_BITS (OP_MASK_EXTMSBD,  OP_SH_EXTMSBD); break;
8461           case 'I': break;
8462           case 't': USE_BITS (OP_MASK_RT,       OP_SH_RT);      break;
8463           case 'T': USE_BITS (OP_MASK_RT,       OP_SH_RT);
8464                     USE_BITS (OP_MASK_SEL,      OP_SH_SEL);     break;
8465           case 'x': USE_BITS (OP_MASK_BBITIND,  OP_SH_BBITIND); break;
8466           case 'X': USE_BITS (OP_MASK_BBITIND,  OP_SH_BBITIND); break;
8467           case 'p': USE_BITS (OP_MASK_CINSPOS,  OP_SH_CINSPOS); break;
8468           case 'P': USE_BITS (OP_MASK_CINSPOS,  OP_SH_CINSPOS); break;
8469           case 'Q': USE_BITS (OP_MASK_SEQI,     OP_SH_SEQI);    break;
8470           case 's': USE_BITS (OP_MASK_CINSLM1,  OP_SH_CINSLM1); break;
8471           case 'S': USE_BITS (OP_MASK_CINSLM1,  OP_SH_CINSLM1); break;
8472
8473           default:
8474             as_bad (_("internal: bad mips opcode (unknown extension operand type `+%c'): %s %s"),
8475                     c, opc->name, opc->args);
8476             return 0;
8477           }
8478         break;
8479       case '<': USE_BITS (OP_MASK_SHAMT,        OP_SH_SHAMT);   break;
8480       case '>': USE_BITS (OP_MASK_SHAMT,        OP_SH_SHAMT);   break;
8481       case 'A': break;
8482       case 'B': USE_BITS (OP_MASK_CODE20,       OP_SH_CODE20);  break;
8483       case 'C': USE_BITS (OP_MASK_COPZ,         OP_SH_COPZ);    break;
8484       case 'D': USE_BITS (OP_MASK_FD,           OP_SH_FD);      break;
8485       case 'E': USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
8486       case 'F': break;
8487       case 'G': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
8488       case 'H': USE_BITS (OP_MASK_SEL,          OP_SH_SEL);     break;
8489       case 'I': break;
8490       case 'J': USE_BITS (OP_MASK_CODE19,       OP_SH_CODE19);  break;
8491       case 'K': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
8492       case 'L': break;
8493       case 'M': USE_BITS (OP_MASK_CCC,          OP_SH_CCC);     break;
8494       case 'N': USE_BITS (OP_MASK_BCC,          OP_SH_BCC);     break;
8495       case 'O': USE_BITS (OP_MASK_ALN,          OP_SH_ALN);     break;
8496       case 'Q': USE_BITS (OP_MASK_VSEL,         OP_SH_VSEL);
8497                 USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
8498       case 'R': USE_BITS (OP_MASK_FR,           OP_SH_FR);      break;
8499       case 'S': USE_BITS (OP_MASK_FS,           OP_SH_FS);      break;
8500       case 'T': USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
8501       case 'V': USE_BITS (OP_MASK_FS,           OP_SH_FS);      break;
8502       case 'W': USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
8503       case 'X': USE_BITS (OP_MASK_FD,           OP_SH_FD);      break;
8504       case 'Y': USE_BITS (OP_MASK_FS,           OP_SH_FS);      break;
8505       case 'Z': USE_BITS (OP_MASK_FT,           OP_SH_FT);      break;
8506       case 'a': USE_BITS (OP_MASK_TARGET,       OP_SH_TARGET);  break;
8507       case 'b': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
8508       case 'c': USE_BITS (OP_MASK_CODE,         OP_SH_CODE);    break;
8509       case 'd': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
8510       case 'f': break;
8511       case 'h': USE_BITS (OP_MASK_PREFX,        OP_SH_PREFX);   break;
8512       case 'i': USE_BITS (OP_MASK_IMMEDIATE,    OP_SH_IMMEDIATE); break;
8513       case 'j': USE_BITS (OP_MASK_DELTA,        OP_SH_DELTA);   break;
8514       case 'k': USE_BITS (OP_MASK_CACHE,        OP_SH_CACHE);   break;
8515       case 'l': break;
8516       case 'o': USE_BITS (OP_MASK_DELTA,        OP_SH_DELTA);   break;
8517       case 'p': USE_BITS (OP_MASK_DELTA,        OP_SH_DELTA);   break;
8518       case 'q': USE_BITS (OP_MASK_CODE2,        OP_SH_CODE2);   break;
8519       case 'r': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
8520       case 's': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
8521       case 't': USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
8522       case 'u': USE_BITS (OP_MASK_IMMEDIATE,    OP_SH_IMMEDIATE); break;
8523       case 'v': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
8524       case 'w': USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
8525       case 'x': break;
8526       case 'z': break;
8527       case 'P': USE_BITS (OP_MASK_PERFREG,      OP_SH_PERFREG); break;
8528       case 'U': USE_BITS (OP_MASK_RD,           OP_SH_RD);
8529                 USE_BITS (OP_MASK_RT,           OP_SH_RT);      break;
8530       case 'e': USE_BITS (OP_MASK_VECBYTE,      OP_SH_VECBYTE); break;
8531       case '%': USE_BITS (OP_MASK_VECALIGN,     OP_SH_VECALIGN); break;
8532       case '[': break;
8533       case ']': break;
8534       case '1': USE_BITS (OP_MASK_SHAMT,        OP_SH_SHAMT);   break;
8535       case '2': USE_BITS (OP_MASK_BP,           OP_SH_BP);      break;
8536       case '3': USE_BITS (OP_MASK_SA3,          OP_SH_SA3);     break;
8537       case '4': USE_BITS (OP_MASK_SA4,          OP_SH_SA4);     break;
8538       case '5': USE_BITS (OP_MASK_IMM8,         OP_SH_IMM8);    break;
8539       case '6': USE_BITS (OP_MASK_RS,           OP_SH_RS);      break;
8540       case '7': USE_BITS (OP_MASK_DSPACC,       OP_SH_DSPACC);  break;
8541       case '8': USE_BITS (OP_MASK_WRDSP,        OP_SH_WRDSP);   break;
8542       case '9': USE_BITS (OP_MASK_DSPACC_S,     OP_SH_DSPACC_S);break;
8543       case '0': USE_BITS (OP_MASK_DSPSFT,       OP_SH_DSPSFT);  break;
8544       case '\'': USE_BITS (OP_MASK_RDDSP,       OP_SH_RDDSP);   break;
8545       case ':': USE_BITS (OP_MASK_DSPSFT_7,     OP_SH_DSPSFT_7);break;
8546       case '@': USE_BITS (OP_MASK_IMM10,        OP_SH_IMM10);   break;
8547       case '!': USE_BITS (OP_MASK_MT_U,         OP_SH_MT_U);    break;
8548       case '$': USE_BITS (OP_MASK_MT_H,         OP_SH_MT_H);    break;
8549       case '*': USE_BITS (OP_MASK_MTACC_T,      OP_SH_MTACC_T); break;
8550       case '&': USE_BITS (OP_MASK_MTACC_D,      OP_SH_MTACC_D); break;
8551       case 'g': USE_BITS (OP_MASK_RD,           OP_SH_RD);      break;
8552       default:
8553         as_bad (_("internal: bad mips opcode (unknown operand type `%c'): %s %s"),
8554                 c, opc->name, opc->args);
8555         return 0;
8556       }
8557 #undef USE_BITS
8558   if (used_bits != 0xffffffff)
8559     {
8560       as_bad (_("internal: bad mips opcode (bits 0x%lx undefined): %s %s"),
8561               ~used_bits & 0xffffffff, opc->name, opc->args);
8562       return 0;
8563     }
8564   return 1;
8565 }
8566
8567 /* UDI immediates.  */
8568 struct mips_immed {
8569   char          type;
8570   unsigned int  shift;
8571   unsigned long mask;
8572   const char *  desc;
8573 };
8574
8575 static const struct mips_immed mips_immed[] = {
8576   { '1',        OP_SH_UDI1,     OP_MASK_UDI1,           0},
8577   { '2',        OP_SH_UDI2,     OP_MASK_UDI2,           0},
8578   { '3',        OP_SH_UDI3,     OP_MASK_UDI3,           0},
8579   { '4',        OP_SH_UDI4,     OP_MASK_UDI4,           0},
8580   { 0,0,0,0 }
8581 };
8582
8583 /* Check whether an odd floating-point register is allowed.  */
8584 static int
8585 mips_oddfpreg_ok (const struct mips_opcode *insn, int argnum)
8586 {
8587   const char *s = insn->name;
8588
8589   if (insn->pinfo == INSN_MACRO)
8590     /* Let a macro pass, we'll catch it later when it is expanded.  */
8591     return 1;
8592
8593   if (ISA_HAS_ODD_SINGLE_FPR (mips_opts.isa))
8594     {
8595       /* Allow odd registers for single-precision ops.  */
8596       switch (insn->pinfo & (FP_S | FP_D))
8597         {
8598         case FP_S:
8599         case 0:
8600           return 1;     /* both single precision - ok */
8601         case FP_D:
8602           return 0;     /* both double precision - fail */
8603         default:
8604           break;
8605         }
8606
8607       /* Cvt.w.x and cvt.x.w allow an odd register for a 'w' or 's' operand.  */
8608       s = strchr (insn->name, '.');
8609       if (argnum == 2)
8610         s = s != NULL ? strchr (s + 1, '.') : NULL;
8611       return (s != NULL && (s[1] == 'w' || s[1] == 's'));
8612     } 
8613
8614   /* Single-precision coprocessor loads and moves are OK too.  */
8615   if ((insn->pinfo & FP_S)
8616       && (insn->pinfo & (INSN_COPROC_MEMORY_DELAY | INSN_STORE_MEMORY
8617                          | INSN_LOAD_COPROC_DELAY | INSN_COPROC_MOVE_DELAY)))
8618     return 1;
8619
8620   return 0;
8621 }
8622
8623 /* This routine assembles an instruction into its binary format.  As a
8624    side effect, it sets one of the global variables imm_reloc or
8625    offset_reloc to the type of relocation to do if one of the operands
8626    is an address expression.  */
8627
8628 static void
8629 mips_ip (char *str, struct mips_cl_insn *ip)
8630 {
8631   char *s;
8632   const char *args;
8633   char c = 0;
8634   struct mips_opcode *insn;
8635   char *argsStart;
8636   unsigned int regno;
8637   unsigned int lastregno = 0;
8638   unsigned int lastpos = 0;
8639   unsigned int limlo, limhi;
8640   char *s_reset;
8641   char save_c = 0;
8642   offsetT min_range, max_range;
8643   int argnum;
8644   unsigned int rtype;
8645
8646   insn_error = NULL;
8647
8648   /* If the instruction contains a '.', we first try to match an instruction
8649      including the '.'.  Then we try again without the '.'.  */
8650   insn = NULL;
8651   for (s = str; *s != '\0' && !ISSPACE (*s); ++s)
8652     continue;
8653
8654   /* If we stopped on whitespace, then replace the whitespace with null for
8655      the call to hash_find.  Save the character we replaced just in case we
8656      have to re-parse the instruction.  */
8657   if (ISSPACE (*s))
8658     {
8659       save_c = *s;
8660       *s++ = '\0';
8661     }
8662
8663   insn = (struct mips_opcode *) hash_find (op_hash, str);
8664
8665   /* If we didn't find the instruction in the opcode table, try again, but
8666      this time with just the instruction up to, but not including the
8667      first '.'.  */
8668   if (insn == NULL)
8669     {
8670       /* Restore the character we overwrite above (if any).  */
8671       if (save_c)
8672         *(--s) = save_c;
8673
8674       /* Scan up to the first '.' or whitespace.  */
8675       for (s = str;
8676            *s != '\0' && *s != '.' && !ISSPACE (*s);
8677            ++s)
8678         continue;
8679
8680       /* If we did not find a '.', then we can quit now.  */
8681       if (*s != '.')
8682         {
8683           insn_error = _("unrecognized opcode");
8684           return;
8685         }
8686
8687       /* Lookup the instruction in the hash table.  */
8688       *s++ = '\0';
8689       if ((insn = (struct mips_opcode *) hash_find (op_hash, str)) == NULL)
8690         {
8691           insn_error = _("unrecognized opcode");
8692           return;
8693         }
8694     }
8695
8696   argsStart = s;
8697   for (;;)
8698     {
8699       bfd_boolean ok;
8700
8701       gas_assert (strcmp (insn->name, str) == 0);
8702
8703       ok = is_opcode_valid (insn);
8704       if (! ok)
8705         {
8706           if (insn + 1 < &mips_opcodes[NUMOPCODES]
8707               && strcmp (insn->name, insn[1].name) == 0)
8708             {
8709               ++insn;
8710               continue;
8711             }
8712           else
8713             {
8714               if (!insn_error)
8715                 {
8716                   static char buf[100];
8717                   sprintf (buf,
8718                            _("opcode not supported on this processor: %s (%s)"),
8719                            mips_cpu_info_from_arch (mips_opts.arch)->name,
8720                            mips_cpu_info_from_isa (mips_opts.isa)->name);
8721                   insn_error = buf;
8722                 }
8723               if (save_c)
8724                 *(--s) = save_c;
8725               return;
8726             }
8727         }
8728
8729       create_insn (ip, insn);
8730       insn_error = NULL;
8731       argnum = 1;
8732       lastregno = 0xffffffff;
8733       for (args = insn->args;; ++args)
8734         {
8735           int is_mdmx;
8736
8737           s += strspn (s, " \t");
8738           is_mdmx = 0;
8739           switch (*args)
8740             {
8741             case '\0':          /* end of args */
8742               if (*s == '\0')
8743                 return;
8744               break;
8745
8746             case '2': /* dsp 2-bit unsigned immediate in bit 11 */
8747               my_getExpression (&imm_expr, s);
8748               check_absolute_expr (ip, &imm_expr);
8749               if ((unsigned long) imm_expr.X_add_number != 1
8750                   && (unsigned long) imm_expr.X_add_number != 3)
8751                 {
8752                   as_bad (_("BALIGN immediate not 1 or 3 (%lu)"),
8753                           (unsigned long) imm_expr.X_add_number);
8754                 }
8755               INSERT_OPERAND (BP, *ip, imm_expr.X_add_number);
8756               imm_expr.X_op = O_absent;
8757               s = expr_end;
8758               continue;
8759
8760             case '3': /* dsp 3-bit unsigned immediate in bit 21 */
8761               my_getExpression (&imm_expr, s);
8762               check_absolute_expr (ip, &imm_expr);
8763               if (imm_expr.X_add_number & ~OP_MASK_SA3)
8764                 {
8765                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
8766                           OP_MASK_SA3, (unsigned long) imm_expr.X_add_number);
8767                 }
8768               INSERT_OPERAND (SA3, *ip, imm_expr.X_add_number);
8769               imm_expr.X_op = O_absent;
8770               s = expr_end;
8771               continue;
8772
8773             case '4': /* dsp 4-bit unsigned immediate in bit 21 */
8774               my_getExpression (&imm_expr, s);
8775               check_absolute_expr (ip, &imm_expr);
8776               if (imm_expr.X_add_number & ~OP_MASK_SA4)
8777                 {
8778                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
8779                           OP_MASK_SA4, (unsigned long) imm_expr.X_add_number);
8780                 }
8781               INSERT_OPERAND (SA4, *ip, imm_expr.X_add_number);
8782               imm_expr.X_op = O_absent;
8783               s = expr_end;
8784               continue;
8785
8786             case '5': /* dsp 8-bit unsigned immediate in bit 16 */
8787               my_getExpression (&imm_expr, s);
8788               check_absolute_expr (ip, &imm_expr);
8789               if (imm_expr.X_add_number & ~OP_MASK_IMM8)
8790                 {
8791                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
8792                           OP_MASK_IMM8, (unsigned long) imm_expr.X_add_number);
8793                 }
8794               INSERT_OPERAND (IMM8, *ip, imm_expr.X_add_number);
8795               imm_expr.X_op = O_absent;
8796               s = expr_end;
8797               continue;
8798
8799             case '6': /* dsp 5-bit unsigned immediate in bit 21 */
8800               my_getExpression (&imm_expr, s);
8801               check_absolute_expr (ip, &imm_expr);
8802               if (imm_expr.X_add_number & ~OP_MASK_RS)
8803                 {
8804                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
8805                           OP_MASK_RS, (unsigned long) imm_expr.X_add_number);
8806                 }
8807               INSERT_OPERAND (RS, *ip, imm_expr.X_add_number);
8808               imm_expr.X_op = O_absent;
8809               s = expr_end;
8810               continue;
8811
8812             case '7': /* four dsp accumulators in bits 11,12 */ 
8813               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
8814                   s[3] >= '0' && s[3] <= '3')
8815                 {
8816                   regno = s[3] - '0';
8817                   s += 4;
8818                   INSERT_OPERAND (DSPACC, *ip, regno);
8819                   continue;
8820                 }
8821               else
8822                 as_bad (_("Invalid dsp acc register"));
8823               break;
8824
8825             case '8': /* dsp 6-bit unsigned immediate in bit 11 */
8826               my_getExpression (&imm_expr, s);
8827               check_absolute_expr (ip, &imm_expr);
8828               if (imm_expr.X_add_number & ~OP_MASK_WRDSP)
8829                 {
8830                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
8831                           OP_MASK_WRDSP,
8832                           (unsigned long) imm_expr.X_add_number);
8833                 }
8834               INSERT_OPERAND (WRDSP, *ip, imm_expr.X_add_number);
8835               imm_expr.X_op = O_absent;
8836               s = expr_end;
8837               continue;
8838
8839             case '9': /* four dsp accumulators in bits 21,22 */
8840               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
8841                   s[3] >= '0' && s[3] <= '3')
8842                 {
8843                   regno = s[3] - '0';
8844                   s += 4;
8845                   INSERT_OPERAND (DSPACC_S, *ip, regno);
8846                   continue;
8847                 }
8848               else
8849                 as_bad (_("Invalid dsp acc register"));
8850               break;
8851
8852             case '0': /* dsp 6-bit signed immediate in bit 20 */
8853               my_getExpression (&imm_expr, s);
8854               check_absolute_expr (ip, &imm_expr);
8855               min_range = -((OP_MASK_DSPSFT + 1) >> 1);
8856               max_range = ((OP_MASK_DSPSFT + 1) >> 1) - 1;
8857               if (imm_expr.X_add_number < min_range ||
8858                   imm_expr.X_add_number > max_range)
8859                 {
8860                   as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
8861                           (long) min_range, (long) max_range,
8862                           (long) imm_expr.X_add_number);
8863                 }
8864               INSERT_OPERAND (DSPSFT, *ip, imm_expr.X_add_number);
8865               imm_expr.X_op = O_absent;
8866               s = expr_end;
8867               continue;
8868
8869             case '\'': /* dsp 6-bit unsigned immediate in bit 16 */
8870               my_getExpression (&imm_expr, s);
8871               check_absolute_expr (ip, &imm_expr);
8872               if (imm_expr.X_add_number & ~OP_MASK_RDDSP)
8873                 {
8874                   as_bad (_("DSP immediate not in range 0..%d (%lu)"),
8875                           OP_MASK_RDDSP,
8876                           (unsigned long) imm_expr.X_add_number);
8877                 }
8878               INSERT_OPERAND (RDDSP, *ip, imm_expr.X_add_number);
8879               imm_expr.X_op = O_absent;
8880               s = expr_end;
8881               continue;
8882
8883             case ':': /* dsp 7-bit signed immediate in bit 19 */
8884               my_getExpression (&imm_expr, s);
8885               check_absolute_expr (ip, &imm_expr);
8886               min_range = -((OP_MASK_DSPSFT_7 + 1) >> 1);
8887               max_range = ((OP_MASK_DSPSFT_7 + 1) >> 1) - 1;
8888               if (imm_expr.X_add_number < min_range ||
8889                   imm_expr.X_add_number > max_range)
8890                 {
8891                   as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
8892                           (long) min_range, (long) max_range,
8893                           (long) imm_expr.X_add_number);
8894                 }
8895               INSERT_OPERAND (DSPSFT_7, *ip, imm_expr.X_add_number);
8896               imm_expr.X_op = O_absent;
8897               s = expr_end;
8898               continue;
8899
8900             case '@': /* dsp 10-bit signed immediate in bit 16 */
8901               my_getExpression (&imm_expr, s);
8902               check_absolute_expr (ip, &imm_expr);
8903               min_range = -((OP_MASK_IMM10 + 1) >> 1);
8904               max_range = ((OP_MASK_IMM10 + 1) >> 1) - 1;
8905               if (imm_expr.X_add_number < min_range ||
8906                   imm_expr.X_add_number > max_range)
8907                 {
8908                   as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
8909                           (long) min_range, (long) max_range,
8910                           (long) imm_expr.X_add_number);
8911                 }
8912               INSERT_OPERAND (IMM10, *ip, imm_expr.X_add_number);
8913               imm_expr.X_op = O_absent;
8914               s = expr_end;
8915               continue;
8916
8917             case '!': /* MT usermode flag bit.  */
8918               my_getExpression (&imm_expr, s);
8919               check_absolute_expr (ip, &imm_expr);
8920               if (imm_expr.X_add_number & ~OP_MASK_MT_U)
8921                 as_bad (_("MT usermode bit not 0 or 1 (%lu)"),
8922                         (unsigned long) imm_expr.X_add_number);
8923               INSERT_OPERAND (MT_U, *ip, imm_expr.X_add_number);
8924               imm_expr.X_op = O_absent;
8925               s = expr_end;
8926               continue;
8927
8928             case '$': /* MT load high flag bit.  */
8929               my_getExpression (&imm_expr, s);
8930               check_absolute_expr (ip, &imm_expr);
8931               if (imm_expr.X_add_number & ~OP_MASK_MT_H)
8932                 as_bad (_("MT load high bit not 0 or 1 (%lu)"),
8933                         (unsigned long) imm_expr.X_add_number);
8934               INSERT_OPERAND (MT_H, *ip, imm_expr.X_add_number);
8935               imm_expr.X_op = O_absent;
8936               s = expr_end;
8937               continue;
8938
8939             case '*': /* four dsp accumulators in bits 18,19 */ 
8940               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
8941                   s[3] >= '0' && s[3] <= '3')
8942                 {
8943                   regno = s[3] - '0';
8944                   s += 4;
8945                   INSERT_OPERAND (MTACC_T, *ip, regno);
8946                   continue;
8947                 }
8948               else
8949                 as_bad (_("Invalid dsp/smartmips acc register"));
8950               break;
8951
8952             case '&': /* four dsp accumulators in bits 13,14 */ 
8953               if (s[0] == '$' && s[1] == 'a' && s[2] == 'c' &&
8954                   s[3] >= '0' && s[3] <= '3')
8955                 {
8956                   regno = s[3] - '0';
8957                   s += 4;
8958                   INSERT_OPERAND (MTACC_D, *ip, regno);
8959                   continue;
8960                 }
8961               else
8962                 as_bad (_("Invalid dsp/smartmips acc register"));
8963               break;
8964
8965             case ',':
8966               ++argnum;
8967               if (*s++ == *args)
8968                 continue;
8969               s--;
8970               switch (*++args)
8971                 {
8972                 case 'r':
8973                 case 'v':
8974                   INSERT_OPERAND (RS, *ip, lastregno);
8975                   continue;
8976
8977                 case 'w':
8978                   INSERT_OPERAND (RT, *ip, lastregno);
8979                   continue;
8980
8981                 case 'W':
8982                   INSERT_OPERAND (FT, *ip, lastregno);
8983                   continue;
8984
8985                 case 'V':
8986                   INSERT_OPERAND (FS, *ip, lastregno);
8987                   continue;
8988                 }
8989               break;
8990
8991             case '(':
8992               /* Handle optional base register.
8993                  Either the base register is omitted or
8994                  we must have a left paren.  */
8995               /* This is dependent on the next operand specifier
8996                  is a base register specification.  */
8997               gas_assert (args[1] == 'b' || args[1] == '5'
8998                       || args[1] == '-' || args[1] == '4');
8999               if (*s == '\0')
9000                 return;
9001
9002             case ')':           /* these must match exactly */
9003             case '[':
9004             case ']':
9005               if (*s++ == *args)
9006                 continue;
9007               break;
9008
9009             case '+':           /* Opcode extension character.  */
9010               switch (*++args)
9011                 {
9012                 case '1':       /* UDI immediates.  */
9013                 case '2':
9014                 case '3':
9015                 case '4':
9016                   {
9017                     const struct mips_immed *imm = mips_immed;
9018
9019                     while (imm->type && imm->type != *args)
9020                       ++imm;
9021                     if (! imm->type)
9022                       internalError ();
9023                     my_getExpression (&imm_expr, s);
9024                     check_absolute_expr (ip, &imm_expr);
9025                     if ((unsigned long) imm_expr.X_add_number & ~imm->mask)
9026                       {
9027                         as_warn (_("Illegal %s number (%lu, 0x%lx)"),
9028                                  imm->desc ? imm->desc : ip->insn_mo->name,
9029                                  (unsigned long) imm_expr.X_add_number,
9030                                  (unsigned long) imm_expr.X_add_number);
9031                               imm_expr.X_add_number &= imm->mask;
9032                       }
9033                     ip->insn_opcode |= ((unsigned long) imm_expr.X_add_number
9034                                         << imm->shift);
9035                     imm_expr.X_op = O_absent;
9036                     s = expr_end;
9037                   }
9038                   continue;
9039                   
9040                 case 'A':               /* ins/ext position, becomes LSB.  */
9041                   limlo = 0;
9042                   limhi = 31;
9043                   goto do_lsb;
9044                 case 'E':
9045                   limlo = 32;
9046                   limhi = 63;
9047                   goto do_lsb;
9048 do_lsb:
9049                   my_getExpression (&imm_expr, s);
9050                   check_absolute_expr (ip, &imm_expr);
9051                   if ((unsigned long) imm_expr.X_add_number < limlo
9052                       || (unsigned long) imm_expr.X_add_number > limhi)
9053                     {
9054                       as_bad (_("Improper position (%lu)"),
9055                               (unsigned long) imm_expr.X_add_number);
9056                       imm_expr.X_add_number = limlo;
9057                     }
9058                   lastpos = imm_expr.X_add_number;
9059                   INSERT_OPERAND (SHAMT, *ip, imm_expr.X_add_number);
9060                   imm_expr.X_op = O_absent;
9061                   s = expr_end;
9062                   continue;
9063
9064                 case 'B':               /* ins size, becomes MSB.  */
9065                   limlo = 1;
9066                   limhi = 32;
9067                   goto do_msb;
9068                 case 'F':
9069                   limlo = 33;
9070                   limhi = 64;
9071                   goto do_msb;
9072 do_msb:
9073                   my_getExpression (&imm_expr, s);
9074                   check_absolute_expr (ip, &imm_expr);
9075                   /* Check for negative input so that small negative numbers
9076                      will not succeed incorrectly.  The checks against
9077                      (pos+size) transitively check "size" itself,
9078                      assuming that "pos" is reasonable.  */
9079                   if ((long) imm_expr.X_add_number < 0
9080                       || ((unsigned long) imm_expr.X_add_number
9081                           + lastpos) < limlo
9082                       || ((unsigned long) imm_expr.X_add_number
9083                           + lastpos) > limhi)
9084                     {
9085                       as_bad (_("Improper insert size (%lu, position %lu)"),
9086                               (unsigned long) imm_expr.X_add_number,
9087                               (unsigned long) lastpos);
9088                       imm_expr.X_add_number = limlo - lastpos;
9089                     }
9090                   INSERT_OPERAND (INSMSB, *ip,
9091                                  lastpos + imm_expr.X_add_number - 1);
9092                   imm_expr.X_op = O_absent;
9093                   s = expr_end;
9094                   continue;
9095
9096                 case 'C':               /* ext size, becomes MSBD.  */
9097                   limlo = 1;
9098                   limhi = 32;
9099                   goto do_msbd;
9100                 case 'G':
9101                   limlo = 33;
9102                   limhi = 64;
9103                   goto do_msbd;
9104                 case 'H':
9105                   limlo = 33;
9106                   limhi = 64;
9107                   goto do_msbd;
9108 do_msbd:
9109                   my_getExpression (&imm_expr, s);
9110                   check_absolute_expr (ip, &imm_expr);
9111                   /* Check for negative input so that small negative numbers
9112                      will not succeed incorrectly.  The checks against
9113                      (pos+size) transitively check "size" itself,
9114                      assuming that "pos" is reasonable.  */
9115                   if ((long) imm_expr.X_add_number < 0
9116                       || ((unsigned long) imm_expr.X_add_number
9117                           + lastpos) < limlo
9118                       || ((unsigned long) imm_expr.X_add_number
9119                           + lastpos) > limhi)
9120                     {
9121                       as_bad (_("Improper extract size (%lu, position %lu)"),
9122                               (unsigned long) imm_expr.X_add_number,
9123                               (unsigned long) lastpos);
9124                       imm_expr.X_add_number = limlo - lastpos;
9125                     }
9126                   INSERT_OPERAND (EXTMSBD, *ip, imm_expr.X_add_number - 1);
9127                   imm_expr.X_op = O_absent;
9128                   s = expr_end;
9129                   continue;
9130
9131                 case 'D':
9132                   /* +D is for disassembly only; never match.  */
9133                   break;
9134
9135                 case 'I':
9136                   /* "+I" is like "I", except that imm2_expr is used.  */
9137                   my_getExpression (&imm2_expr, s);
9138                   if (imm2_expr.X_op != O_big
9139                       && imm2_expr.X_op != O_constant)
9140                   insn_error = _("absolute expression required");
9141                   if (HAVE_32BIT_GPRS)
9142                     normalize_constant_expr (&imm2_expr);
9143                   s = expr_end;
9144                   continue;
9145
9146                 case 'T': /* Coprocessor register.  */
9147                   /* +T is for disassembly only; never match.  */
9148                   break;
9149
9150                 case 't': /* Coprocessor register number.  */
9151                   if (s[0] == '$' && ISDIGIT (s[1]))
9152                     {
9153                       ++s;
9154                       regno = 0;
9155                       do
9156                         {
9157                           regno *= 10;
9158                           regno += *s - '0';
9159                           ++s;
9160                         }
9161                       while (ISDIGIT (*s));
9162                       if (regno > 31)
9163                         as_bad (_("Invalid register number (%d)"), regno);
9164                       else
9165                         {
9166                           INSERT_OPERAND (RT, *ip, regno);
9167                           continue;
9168                         }
9169                     }
9170                   else
9171                     as_bad (_("Invalid coprocessor 0 register number"));
9172                   break;
9173
9174                 case 'x':
9175                   /* bbit[01] and bbit[01]32 bit index.  Give error if index
9176                      is not in the valid range.  */
9177                   my_getExpression (&imm_expr, s);
9178                   check_absolute_expr (ip, &imm_expr);
9179                   if ((unsigned) imm_expr.X_add_number > 31)
9180                     {
9181                       as_bad (_("Improper bit index (%lu)"),
9182                               (unsigned long) imm_expr.X_add_number);
9183                       imm_expr.X_add_number = 0;
9184                     }
9185                   INSERT_OPERAND (BBITIND, *ip, imm_expr.X_add_number);
9186                   imm_expr.X_op = O_absent;
9187                   s = expr_end;
9188                   continue;
9189
9190                 case 'X':
9191                   /* bbit[01] bit index when bbit is used but we generate
9192                      bbit[01]32 because the index is over 32.  Move to the
9193                      next candidate if index is not in the valid range.  */
9194                   my_getExpression (&imm_expr, s);
9195                   check_absolute_expr (ip, &imm_expr);
9196                   if ((unsigned) imm_expr.X_add_number < 32
9197                       || (unsigned) imm_expr.X_add_number > 63)
9198                     break;
9199                   INSERT_OPERAND (BBITIND, *ip, imm_expr.X_add_number - 32);
9200                   imm_expr.X_op = O_absent;
9201                   s = expr_end;
9202                   continue;
9203
9204                 case 'p':
9205                   /* cins, cins32, exts and exts32 position field.  Give error
9206                      if it's not in the valid range.  */
9207                   my_getExpression (&imm_expr, s);
9208                   check_absolute_expr (ip, &imm_expr);
9209                   if ((unsigned) imm_expr.X_add_number > 31)
9210                     {
9211                       as_bad (_("Improper position (%lu)"),
9212                               (unsigned long) imm_expr.X_add_number);
9213                       imm_expr.X_add_number = 0;
9214                     }
9215                   /* Make the pos explicit to simplify +S.  */
9216                   lastpos = imm_expr.X_add_number + 32;
9217                   INSERT_OPERAND (CINSPOS, *ip, imm_expr.X_add_number);
9218                   imm_expr.X_op = O_absent;
9219                   s = expr_end;
9220                   continue;
9221
9222                 case 'P':
9223                   /* cins, cins32, exts and exts32 position field.  Move to
9224                      the next candidate if it's not in the valid range.  */
9225                   my_getExpression (&imm_expr, s);
9226                   check_absolute_expr (ip, &imm_expr);
9227                   if ((unsigned) imm_expr.X_add_number < 32
9228                       || (unsigned) imm_expr.X_add_number > 63)
9229                     break;
9230                   lastpos = imm_expr.X_add_number;
9231                   INSERT_OPERAND (CINSPOS, *ip, imm_expr.X_add_number - 32);
9232                   imm_expr.X_op = O_absent;
9233                   s = expr_end;
9234                   continue;
9235
9236                 case 's':
9237                   /* cins and exts length-minus-one field.  */
9238                   my_getExpression (&imm_expr, s);
9239                   check_absolute_expr (ip, &imm_expr);
9240                   if ((unsigned long) imm_expr.X_add_number > 31)
9241                     {
9242                       as_bad (_("Improper size (%lu)"),
9243                               (unsigned long) imm_expr.X_add_number);
9244                       imm_expr.X_add_number = 0;
9245                     }
9246                   INSERT_OPERAND (CINSLM1, *ip, imm_expr.X_add_number);
9247                   imm_expr.X_op = O_absent;
9248                   s = expr_end;
9249                   continue;
9250
9251                 case 'S':
9252                   /* cins32/exts32 and cins/exts aliasing cint32/exts32
9253                      length-minus-one field.  */
9254                   my_getExpression (&imm_expr, s);
9255                   check_absolute_expr (ip, &imm_expr);
9256                   if ((long) imm_expr.X_add_number < 0
9257                       || (unsigned long) imm_expr.X_add_number + lastpos > 63)
9258                     {
9259                       as_bad (_("Improper size (%lu)"),
9260                               (unsigned long) imm_expr.X_add_number);
9261                       imm_expr.X_add_number = 0;
9262                     }
9263                   INSERT_OPERAND (CINSLM1, *ip, imm_expr.X_add_number);
9264                   imm_expr.X_op = O_absent;
9265                   s = expr_end;
9266                   continue;
9267
9268                 case 'Q':
9269                   /* seqi/snei immediate field.  */
9270                   my_getExpression (&imm_expr, s);
9271                   check_absolute_expr (ip, &imm_expr);
9272                   if ((long) imm_expr.X_add_number < -512
9273                       || (long) imm_expr.X_add_number >= 512)
9274                     {
9275                       as_bad (_("Improper immediate (%ld)"),
9276                                (long) imm_expr.X_add_number);
9277                       imm_expr.X_add_number = 0;
9278                     }
9279                   INSERT_OPERAND (SEQI, *ip, imm_expr.X_add_number);
9280                   imm_expr.X_op = O_absent;
9281                   s = expr_end;
9282                   continue;
9283
9284                 default:
9285                   as_bad (_("internal: bad mips opcode (unknown extension operand type `+%c'): %s %s"),
9286                     *args, insn->name, insn->args);
9287                   /* Further processing is fruitless.  */
9288                   return;
9289                 }
9290               break;
9291
9292             case '<':           /* must be at least one digit */
9293               /*
9294                * According to the manual, if the shift amount is greater
9295                * than 31 or less than 0, then the shift amount should be
9296                * mod 32.  In reality the mips assembler issues an error.
9297                * We issue a warning and mask out all but the low 5 bits.
9298                */
9299               my_getExpression (&imm_expr, s);
9300               check_absolute_expr (ip, &imm_expr);
9301               if ((unsigned long) imm_expr.X_add_number > 31)
9302                 as_warn (_("Improper shift amount (%lu)"),
9303                          (unsigned long) imm_expr.X_add_number);
9304               INSERT_OPERAND (SHAMT, *ip, imm_expr.X_add_number);
9305               imm_expr.X_op = O_absent;
9306               s = expr_end;
9307               continue;
9308
9309             case '>':           /* shift amount minus 32 */
9310               my_getExpression (&imm_expr, s);
9311               check_absolute_expr (ip, &imm_expr);
9312               if ((unsigned long) imm_expr.X_add_number < 32
9313                   || (unsigned long) imm_expr.X_add_number > 63)
9314                 break;
9315               INSERT_OPERAND (SHAMT, *ip, imm_expr.X_add_number - 32);
9316               imm_expr.X_op = O_absent;
9317               s = expr_end;
9318               continue;
9319
9320             case 'k':           /* cache code */
9321             case 'h':           /* prefx code */
9322             case '1':           /* sync type */
9323               my_getExpression (&imm_expr, s);
9324               check_absolute_expr (ip, &imm_expr);
9325               if ((unsigned long) imm_expr.X_add_number > 31)
9326                 as_warn (_("Invalid value for `%s' (%lu)"),
9327                          ip->insn_mo->name,
9328                          (unsigned long) imm_expr.X_add_number);
9329               if (*args == 'k')
9330                 {
9331                   if (mips_fix_cn63xxp1 && strcmp ("pref", insn->name) == 0)
9332                     switch (imm_expr.X_add_number)
9333                       {
9334                       case 5:
9335                       case 25:
9336                       case 26:
9337                       case 27:
9338                       case 28:
9339                       case 29:
9340                       case 30:
9341                       case 31:  /* These are ok.  */
9342                         break;
9343
9344                       default:  /* The rest must be changed to 28.  */
9345                         imm_expr.X_add_number = 28;
9346                         break;
9347                       }
9348                   INSERT_OPERAND (CACHE, *ip, imm_expr.X_add_number);
9349                 }
9350               else if (*args == 'h')
9351                 INSERT_OPERAND (PREFX, *ip, imm_expr.X_add_number);
9352               else
9353                 INSERT_OPERAND (SHAMT, *ip, imm_expr.X_add_number);
9354               imm_expr.X_op = O_absent;
9355               s = expr_end;
9356               continue;
9357
9358             case 'c':           /* break code */
9359               my_getExpression (&imm_expr, s);
9360               check_absolute_expr (ip, &imm_expr);
9361               if ((unsigned long) imm_expr.X_add_number > OP_MASK_CODE)
9362                 as_warn (_("Code for %s not in range 0..1023 (%lu)"),
9363                          ip->insn_mo->name,
9364                          (unsigned long) imm_expr.X_add_number);
9365               INSERT_OPERAND (CODE, *ip, imm_expr.X_add_number);
9366               imm_expr.X_op = O_absent;
9367               s = expr_end;
9368               continue;
9369
9370             case 'q':           /* lower break code */
9371               my_getExpression (&imm_expr, s);
9372               check_absolute_expr (ip, &imm_expr);
9373               if ((unsigned long) imm_expr.X_add_number > OP_MASK_CODE2)
9374                 as_warn (_("Lower code for %s not in range 0..1023 (%lu)"),
9375                          ip->insn_mo->name,
9376                          (unsigned long) imm_expr.X_add_number);
9377               INSERT_OPERAND (CODE2, *ip, imm_expr.X_add_number);
9378               imm_expr.X_op = O_absent;
9379               s = expr_end;
9380               continue;
9381
9382             case 'B':           /* 20-bit syscall/break code.  */
9383               my_getExpression (&imm_expr, s);
9384               check_absolute_expr (ip, &imm_expr);
9385               if ((unsigned long) imm_expr.X_add_number > OP_MASK_CODE20)
9386                 as_warn (_("Code for %s not in range 0..1048575 (%lu)"),
9387                          ip->insn_mo->name,
9388                          (unsigned long) imm_expr.X_add_number);
9389               INSERT_OPERAND (CODE20, *ip, imm_expr.X_add_number);
9390               imm_expr.X_op = O_absent;
9391               s = expr_end;
9392               continue;
9393
9394             case 'C':           /* Coprocessor code */
9395               my_getExpression (&imm_expr, s);
9396               check_absolute_expr (ip, &imm_expr);
9397               if ((unsigned long) imm_expr.X_add_number > OP_MASK_COPZ)
9398                 {
9399                   as_warn (_("Coproccesor code > 25 bits (%lu)"),
9400                            (unsigned long) imm_expr.X_add_number);
9401                   imm_expr.X_add_number &= OP_MASK_COPZ;
9402                 }
9403               INSERT_OPERAND (COPZ, *ip, imm_expr.X_add_number);
9404               imm_expr.X_op = O_absent;
9405               s = expr_end;
9406               continue;
9407
9408             case 'J':           /* 19-bit wait code.  */
9409               my_getExpression (&imm_expr, s);
9410               check_absolute_expr (ip, &imm_expr);
9411               if ((unsigned long) imm_expr.X_add_number > OP_MASK_CODE19)
9412                 {
9413                   as_warn (_("Illegal 19-bit code (%lu)"),
9414                            (unsigned long) imm_expr.X_add_number);
9415                   imm_expr.X_add_number &= OP_MASK_CODE19;
9416                 }
9417               INSERT_OPERAND (CODE19, *ip, imm_expr.X_add_number);
9418               imm_expr.X_op = O_absent;
9419               s = expr_end;
9420               continue;
9421
9422             case 'P':           /* Performance register.  */
9423               my_getExpression (&imm_expr, s);
9424               check_absolute_expr (ip, &imm_expr);
9425               if (imm_expr.X_add_number != 0 && imm_expr.X_add_number != 1)
9426                 as_warn (_("Invalid performance register (%lu)"),
9427                          (unsigned long) imm_expr.X_add_number);
9428               INSERT_OPERAND (PERFREG, *ip, imm_expr.X_add_number);
9429               imm_expr.X_op = O_absent;
9430               s = expr_end;
9431               continue;
9432
9433             case 'G':           /* Coprocessor destination register.  */
9434               if (((ip->insn_opcode >> OP_SH_OP) & OP_MASK_OP) == OP_OP_COP0)
9435                 ok = reg_lookup (&s, RTYPE_NUM | RTYPE_CP0, &regno);
9436               else
9437                 ok = reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &regno);
9438               INSERT_OPERAND (RD, *ip, regno);
9439               if (ok) 
9440                 {
9441                   lastregno = regno;
9442                   continue;
9443                 }
9444               else
9445                 break;
9446
9447             case 'b':           /* base register */
9448             case 'd':           /* destination register */
9449             case 's':           /* source register */
9450             case 't':           /* target register */
9451             case 'r':           /* both target and source */
9452             case 'v':           /* both dest and source */
9453             case 'w':           /* both dest and target */
9454             case 'E':           /* coprocessor target register */
9455             case 'K':           /* 'rdhwr' destination register */
9456             case 'x':           /* ignore register name */
9457             case 'z':           /* must be zero register */
9458             case 'U':           /* destination register (clo/clz).  */
9459             case 'g':           /* coprocessor destination register */
9460               s_reset = s;            
9461               if (*args == 'E' || *args == 'K')
9462                 ok = reg_lookup (&s, RTYPE_NUM, &regno);
9463               else
9464                 {
9465                   ok = reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &regno);
9466                   if (regno == AT && mips_opts.at)
9467                     {
9468                       if (mips_opts.at == ATREG)
9469                         as_warn (_("used $at without \".set noat\""));
9470                       else
9471                         as_warn (_("used $%u with \".set at=$%u\""),
9472                                  regno, mips_opts.at);
9473                     }
9474                 }
9475               if (ok)
9476                 {
9477                   c = *args;
9478                   if (*s == ' ')
9479                     ++s;
9480                   if (args[1] != *s)
9481                     {
9482                       if (c == 'r' || c == 'v' || c == 'w')
9483                         {
9484                           regno = lastregno;
9485                           s = s_reset;
9486                           ++args;
9487                         }
9488                     }
9489                   /* 'z' only matches $0.  */
9490                   if (c == 'z' && regno != 0)
9491                     break;
9492
9493                   if (c == 's' && !strncmp (ip->insn_mo->name, "jalr", 4))
9494                     {
9495                       if (regno == lastregno)
9496                         {
9497                           insn_error = _("source and destination must be different");
9498                           continue;
9499                         }
9500                       if (regno == 31 && lastregno == 0xffffffff)
9501                         {
9502                           insn_error = _("a destination register must be supplied");
9503                           continue;
9504                         }
9505                     }
9506         /* Now that we have assembled one operand, we use the args string
9507          * to figure out where it goes in the instruction.  */
9508                   switch (c)
9509                     {
9510                     case 'r':
9511                     case 's':
9512                     case 'v':
9513                     case 'b':
9514                       INSERT_OPERAND (RS, *ip, regno);
9515                       break;
9516                     case 'd':
9517                     case 'G':
9518                     case 'K':
9519                     case 'g':
9520                       INSERT_OPERAND (RD, *ip, regno);
9521                       break;
9522                     case 'U':
9523                       INSERT_OPERAND (RD, *ip, regno);
9524                       INSERT_OPERAND (RT, *ip, regno);
9525                       break;
9526                     case 'w':
9527                     case 't':
9528                     case 'E':
9529                       INSERT_OPERAND (RT, *ip, regno);
9530                       break;
9531                     case 'x':
9532                       /* This case exists because on the r3000 trunc
9533                          expands into a macro which requires a gp
9534                          register.  On the r6000 or r4000 it is
9535                          assembled into a single instruction which
9536                          ignores the register.  Thus the insn version
9537                          is MIPS_ISA2 and uses 'x', and the macro
9538                          version is MIPS_ISA1 and uses 't'.  */
9539                       break;
9540                     case 'z':
9541                       /* This case is for the div instruction, which
9542                          acts differently if the destination argument
9543                          is $0.  This only matches $0, and is checked
9544                          outside the switch.  */
9545                       break;
9546                     case 'D':
9547                       /* Itbl operand; not yet implemented. FIXME ?? */
9548                       break;
9549                       /* What about all other operands like 'i', which
9550                          can be specified in the opcode table? */
9551                     }
9552                   lastregno = regno;
9553                   continue;
9554                 }
9555               switch (*args++)
9556                 {
9557                 case 'r':
9558                 case 'v':
9559                   INSERT_OPERAND (RS, *ip, lastregno);
9560                   continue;
9561                 case 'w':
9562                   INSERT_OPERAND (RT, *ip, lastregno);
9563                   continue;
9564                 }
9565               break;
9566
9567             case 'O':           /* MDMX alignment immediate constant.  */
9568               my_getExpression (&imm_expr, s);
9569               check_absolute_expr (ip, &imm_expr);
9570               if ((unsigned long) imm_expr.X_add_number > OP_MASK_ALN)
9571                 as_warn (_("Improper align amount (%ld), using low bits"),
9572                          (long) imm_expr.X_add_number);
9573               INSERT_OPERAND (ALN, *ip, imm_expr.X_add_number);
9574               imm_expr.X_op = O_absent;
9575               s = expr_end;
9576               continue;
9577
9578             case 'Q':           /* MDMX vector, element sel, or const.  */
9579               if (s[0] != '$')
9580                 {
9581                   /* MDMX Immediate.  */
9582                   my_getExpression (&imm_expr, s);
9583                   check_absolute_expr (ip, &imm_expr);
9584                   if ((unsigned long) imm_expr.X_add_number > OP_MASK_FT)
9585                     as_warn (_("Invalid MDMX Immediate (%ld)"),
9586                              (long) imm_expr.X_add_number);
9587                   INSERT_OPERAND (FT, *ip, imm_expr.X_add_number);
9588                   if (ip->insn_opcode & (OP_MASK_VSEL << OP_SH_VSEL))
9589                     ip->insn_opcode |= MDMX_FMTSEL_IMM_QH << OP_SH_VSEL;
9590                   else
9591                     ip->insn_opcode |= MDMX_FMTSEL_IMM_OB << OP_SH_VSEL;
9592                   imm_expr.X_op = O_absent;
9593                   s = expr_end;
9594                   continue;
9595                 }
9596               /* Not MDMX Immediate.  Fall through.  */
9597             case 'X':           /* MDMX destination register.  */
9598             case 'Y':           /* MDMX source register.  */
9599             case 'Z':           /* MDMX target register.  */
9600               is_mdmx = 1;
9601             case 'D':           /* floating point destination register */
9602             case 'S':           /* floating point source register */
9603             case 'T':           /* floating point target register */
9604             case 'R':           /* floating point source register */
9605             case 'V':
9606             case 'W':
9607               rtype = RTYPE_FPU;
9608               if (is_mdmx
9609                   || (mips_opts.ase_mdmx
9610                       && (ip->insn_mo->pinfo & FP_D)
9611                       && (ip->insn_mo->pinfo & (INSN_COPROC_MOVE_DELAY
9612                                                 | INSN_COPROC_MEMORY_DELAY
9613                                                 | INSN_LOAD_COPROC_DELAY
9614                                                 | INSN_LOAD_MEMORY_DELAY
9615                                                 | INSN_STORE_MEMORY))))
9616                 rtype |= RTYPE_VEC;
9617               s_reset = s;
9618               if (reg_lookup (&s, rtype, &regno))
9619                 {
9620                   if ((regno & 1) != 0
9621                       && HAVE_32BIT_FPRS
9622                       && ! mips_oddfpreg_ok (ip->insn_mo, argnum))
9623                     as_warn (_("Float register should be even, was %d"),
9624                              regno);
9625
9626                   c = *args;
9627                   if (*s == ' ')
9628                     ++s;
9629                   if (args[1] != *s)
9630                     {
9631                       if (c == 'V' || c == 'W')
9632                         {
9633                           regno = lastregno;
9634                           s = s_reset;
9635                           ++args;
9636                         }
9637                     }
9638                   switch (c)
9639                     {
9640                     case 'D':
9641                     case 'X':
9642                       INSERT_OPERAND (FD, *ip, regno);
9643                       break;
9644                     case 'V':
9645                     case 'S':
9646                     case 'Y':
9647                       INSERT_OPERAND (FS, *ip, regno);
9648                       break;
9649                     case 'Q':
9650                       /* This is like 'Z', but also needs to fix the MDMX
9651                          vector/scalar select bits.  Note that the
9652                          scalar immediate case is handled above.  */
9653                       if (*s == '[')
9654                         {
9655                           int is_qh = (ip->insn_opcode & (1 << OP_SH_VSEL));
9656                           int max_el = (is_qh ? 3 : 7);
9657                           s++;
9658                           my_getExpression(&imm_expr, s);
9659                           check_absolute_expr (ip, &imm_expr);
9660                           s = expr_end;
9661                           if (imm_expr.X_add_number > max_el)
9662                             as_bad (_("Bad element selector %ld"),
9663                                     (long) imm_expr.X_add_number);
9664                           imm_expr.X_add_number &= max_el;
9665                           ip->insn_opcode |= (imm_expr.X_add_number
9666                                               << (OP_SH_VSEL +
9667                                                   (is_qh ? 2 : 1)));
9668                           imm_expr.X_op = O_absent;
9669                           if (*s != ']')
9670                             as_warn (_("Expecting ']' found '%s'"), s);
9671                           else
9672                             s++;
9673                         }
9674                       else
9675                         {
9676                           if (ip->insn_opcode & (OP_MASK_VSEL << OP_SH_VSEL))
9677                             ip->insn_opcode |= (MDMX_FMTSEL_VEC_QH
9678                                                 << OP_SH_VSEL);
9679                           else
9680                             ip->insn_opcode |= (MDMX_FMTSEL_VEC_OB <<
9681                                                 OP_SH_VSEL);
9682                         }
9683                       /* Fall through */
9684                     case 'W':
9685                     case 'T':
9686                     case 'Z':
9687                       INSERT_OPERAND (FT, *ip, regno);
9688                       break;
9689                     case 'R':
9690                       INSERT_OPERAND (FR, *ip, regno);
9691                       break;
9692                     }
9693                   lastregno = regno;
9694                   continue;
9695                 }
9696
9697               switch (*args++)
9698                 {
9699                 case 'V':
9700                   INSERT_OPERAND (FS, *ip, lastregno);
9701                   continue;
9702                 case 'W':
9703                   INSERT_OPERAND (FT, *ip, lastregno);
9704                   continue;
9705                 }
9706               break;
9707
9708             case 'I':
9709               my_getExpression (&imm_expr, s);
9710               if (imm_expr.X_op != O_big
9711                   && imm_expr.X_op != O_constant)
9712                 insn_error = _("absolute expression required");
9713               if (HAVE_32BIT_GPRS)
9714                 normalize_constant_expr (&imm_expr);
9715               s = expr_end;
9716               continue;
9717
9718             case 'A':
9719               my_getExpression (&offset_expr, s);
9720               normalize_address_expr (&offset_expr);
9721               *imm_reloc = BFD_RELOC_32;
9722               s = expr_end;
9723               continue;
9724
9725             case 'F':
9726             case 'L':
9727             case 'f':
9728             case 'l':
9729               {
9730                 int f64;
9731                 int using_gprs;
9732                 char *save_in;
9733                 char *err;
9734                 unsigned char temp[8];
9735                 int len;
9736                 unsigned int length;
9737                 segT seg;
9738                 subsegT subseg;
9739                 char *p;
9740
9741                 /* These only appear as the last operand in an
9742                    instruction, and every instruction that accepts
9743                    them in any variant accepts them in all variants.
9744                    This means we don't have to worry about backing out
9745                    any changes if the instruction does not match.
9746
9747                    The difference between them is the size of the
9748                    floating point constant and where it goes.  For 'F'
9749                    and 'L' the constant is 64 bits; for 'f' and 'l' it
9750                    is 32 bits.  Where the constant is placed is based
9751                    on how the MIPS assembler does things:
9752                     F -- .rdata
9753                     L -- .lit8
9754                     f -- immediate value
9755                     l -- .lit4
9756
9757                     The .lit4 and .lit8 sections are only used if
9758                     permitted by the -G argument.
9759
9760                     The code below needs to know whether the target register
9761                     is 32 or 64 bits wide.  It relies on the fact 'f' and
9762                     'F' are used with GPR-based instructions and 'l' and
9763                     'L' are used with FPR-based instructions.  */
9764
9765                 f64 = *args == 'F' || *args == 'L';
9766                 using_gprs = *args == 'F' || *args == 'f';
9767
9768                 save_in = input_line_pointer;
9769                 input_line_pointer = s;
9770                 err = md_atof (f64 ? 'd' : 'f', (char *) temp, &len);
9771                 length = len;
9772                 s = input_line_pointer;
9773                 input_line_pointer = save_in;
9774                 if (err != NULL && *err != '\0')
9775                   {
9776                     as_bad (_("Bad floating point constant: %s"), err);
9777                     memset (temp, '\0', sizeof temp);
9778                     length = f64 ? 8 : 4;
9779                   }
9780
9781                 gas_assert (length == (unsigned) (f64 ? 8 : 4));
9782
9783                 if (*args == 'f'
9784                     || (*args == 'l'
9785                         && (g_switch_value < 4
9786                             || (temp[0] == 0 && temp[1] == 0)
9787                             || (temp[2] == 0 && temp[3] == 0))))
9788                   {
9789                     imm_expr.X_op = O_constant;
9790                     if (! target_big_endian)
9791                       imm_expr.X_add_number = bfd_getl32 (temp);
9792                     else
9793                       imm_expr.X_add_number = bfd_getb32 (temp);
9794                   }
9795                 else if (length > 4
9796                          && ! mips_disable_float_construction
9797                          /* Constants can only be constructed in GPRs and
9798                             copied to FPRs if the GPRs are at least as wide
9799                             as the FPRs.  Force the constant into memory if
9800                             we are using 64-bit FPRs but the GPRs are only
9801                             32 bits wide.  */
9802                          && (using_gprs
9803                              || ! (HAVE_64BIT_FPRS && HAVE_32BIT_GPRS))
9804                          && ((temp[0] == 0 && temp[1] == 0)
9805                              || (temp[2] == 0 && temp[3] == 0))
9806                          && ((temp[4] == 0 && temp[5] == 0)
9807                              || (temp[6] == 0 && temp[7] == 0)))
9808                   {
9809                     /* The value is simple enough to load with a couple of
9810                        instructions.  If using 32-bit registers, set
9811                        imm_expr to the high order 32 bits and offset_expr to
9812                        the low order 32 bits.  Otherwise, set imm_expr to
9813                        the entire 64 bit constant.  */
9814                     if (using_gprs ? HAVE_32BIT_GPRS : HAVE_32BIT_FPRS)
9815                       {
9816                         imm_expr.X_op = O_constant;
9817                         offset_expr.X_op = O_constant;
9818                         if (! target_big_endian)
9819                           {
9820                             imm_expr.X_add_number = bfd_getl32 (temp + 4);
9821                             offset_expr.X_add_number = bfd_getl32 (temp);
9822                           }
9823                         else
9824                           {
9825                             imm_expr.X_add_number = bfd_getb32 (temp);
9826                             offset_expr.X_add_number = bfd_getb32 (temp + 4);
9827                           }
9828                         if (offset_expr.X_add_number == 0)
9829                           offset_expr.X_op = O_absent;
9830                       }
9831                     else if (sizeof (imm_expr.X_add_number) > 4)
9832                       {
9833                         imm_expr.X_op = O_constant;
9834                         if (! target_big_endian)
9835                           imm_expr.X_add_number = bfd_getl64 (temp);
9836                         else
9837                           imm_expr.X_add_number = bfd_getb64 (temp);
9838                       }
9839                     else
9840                       {
9841                         imm_expr.X_op = O_big;
9842                         imm_expr.X_add_number = 4;
9843                         if (! target_big_endian)
9844                           {
9845                             generic_bignum[0] = bfd_getl16 (temp);
9846                             generic_bignum[1] = bfd_getl16 (temp + 2);
9847                             generic_bignum[2] = bfd_getl16 (temp + 4);
9848                             generic_bignum[3] = bfd_getl16 (temp + 6);
9849                           }
9850                         else
9851                           {
9852                             generic_bignum[0] = bfd_getb16 (temp + 6);
9853                             generic_bignum[1] = bfd_getb16 (temp + 4);
9854                             generic_bignum[2] = bfd_getb16 (temp + 2);
9855                             generic_bignum[3] = bfd_getb16 (temp);
9856                           }
9857                       }
9858                   }
9859                 else
9860                   {
9861                     const char *newname;
9862                     segT new_seg;
9863
9864                     /* Switch to the right section.  */
9865                     seg = now_seg;
9866                     subseg = now_subseg;
9867                     switch (*args)
9868                       {
9869                       default: /* unused default case avoids warnings.  */
9870                       case 'L':
9871                         newname = RDATA_SECTION_NAME;
9872                         if (g_switch_value >= 8)
9873                           newname = ".lit8";
9874                         break;
9875                       case 'F':
9876                         newname = RDATA_SECTION_NAME;
9877                         break;
9878                       case 'l':
9879                         gas_assert (g_switch_value >= 4);
9880                         newname = ".lit4";
9881                         break;
9882                       }
9883                     new_seg = subseg_new (newname, (subsegT) 0);
9884                     if (IS_ELF)
9885                       bfd_set_section_flags (stdoutput, new_seg,
9886                                              (SEC_ALLOC
9887                                               | SEC_LOAD
9888                                               | SEC_READONLY
9889                                               | SEC_DATA));
9890                     frag_align (*args == 'l' ? 2 : 3, 0, 0);
9891                     if (IS_ELF && strncmp (TARGET_OS, "elf", 3) != 0)
9892                       record_alignment (new_seg, 4);
9893                     else
9894                       record_alignment (new_seg, *args == 'l' ? 2 : 3);
9895                     if (seg == now_seg)
9896                       as_bad (_("Can't use floating point insn in this section"));
9897
9898                     /* Set the argument to the current address in the
9899                        section.  */
9900                     offset_expr.X_op = O_symbol;
9901                     offset_expr.X_add_symbol = symbol_temp_new_now ();
9902                     offset_expr.X_add_number = 0;
9903
9904                     /* Put the floating point number into the section.  */
9905                     p = frag_more ((int) length);
9906                     memcpy (p, temp, length);
9907
9908                     /* Switch back to the original section.  */
9909                     subseg_set (seg, subseg);
9910                   }
9911               }
9912               continue;
9913
9914             case 'i':           /* 16 bit unsigned immediate */
9915             case 'j':           /* 16 bit signed immediate */
9916               *imm_reloc = BFD_RELOC_LO16;
9917               if (my_getSmallExpression (&imm_expr, imm_reloc, s) == 0)
9918                 {
9919                   int more;
9920                   offsetT minval, maxval;
9921
9922                   more = (insn + 1 < &mips_opcodes[NUMOPCODES]
9923                           && strcmp (insn->name, insn[1].name) == 0);
9924
9925                   /* If the expression was written as an unsigned number,
9926                      only treat it as signed if there are no more
9927                      alternatives.  */
9928                   if (more
9929                       && *args == 'j'
9930                       && sizeof (imm_expr.X_add_number) <= 4
9931                       && imm_expr.X_op == O_constant
9932                       && imm_expr.X_add_number < 0
9933                       && imm_expr.X_unsigned
9934                       && HAVE_64BIT_GPRS)
9935                     break;
9936
9937                   /* For compatibility with older assemblers, we accept
9938                      0x8000-0xffff as signed 16-bit numbers when only
9939                      signed numbers are allowed.  */
9940                   if (*args == 'i')
9941                     minval = 0, maxval = 0xffff;
9942                   else if (more)
9943                     minval = -0x8000, maxval = 0x7fff;
9944                   else
9945                     minval = -0x8000, maxval = 0xffff;
9946
9947                   if (imm_expr.X_op != O_constant
9948                       || imm_expr.X_add_number < minval
9949                       || imm_expr.X_add_number > maxval)
9950                     {
9951                       if (more)
9952                         break;
9953                       if (imm_expr.X_op == O_constant
9954                           || imm_expr.X_op == O_big)
9955                         as_bad (_("expression out of range"));
9956                     }
9957                 }
9958               s = expr_end;
9959               continue;
9960
9961             case 'o':           /* 16 bit offset */
9962               offset_reloc[0] = BFD_RELOC_LO16;
9963               offset_reloc[1] = BFD_RELOC_UNUSED;
9964               offset_reloc[2] = BFD_RELOC_UNUSED;
9965
9966               /* Check whether there is only a single bracketed expression
9967                  left.  If so, it must be the base register and the
9968                  constant must be zero.  */
9969               offset_reloc[0] = BFD_RELOC_LO16;
9970               offset_reloc[1] = BFD_RELOC_UNUSED;
9971               offset_reloc[2] = BFD_RELOC_UNUSED;
9972               if (*s == '(' && strchr (s + 1, '(') == 0)
9973                 {
9974                   offset_expr.X_op = O_constant;
9975                   offset_expr.X_add_number = 0;
9976                   continue;
9977                 }
9978
9979               /* If this value won't fit into a 16 bit offset, then go
9980                  find a macro that will generate the 32 bit offset
9981                  code pattern.  */
9982               if (my_getSmallExpression (&offset_expr, offset_reloc, s) == 0
9983                   && (offset_expr.X_op != O_constant
9984                       || offset_expr.X_add_number >= 0x8000
9985                       || offset_expr.X_add_number < -0x8000))
9986                 break;
9987
9988               s = expr_end;
9989               continue;
9990
9991             case 'p':           /* pc relative offset */
9992               *offset_reloc = BFD_RELOC_16_PCREL_S2;
9993               my_getExpression (&offset_expr, s);
9994               s = expr_end;
9995               continue;
9996
9997             case 'u':           /* upper 16 bits */
9998               if (my_getSmallExpression (&imm_expr, imm_reloc, s) == 0
9999                   && imm_expr.X_op == O_constant
10000                   && (imm_expr.X_add_number < 0
10001                       || imm_expr.X_add_number >= 0x10000))
10002                 as_bad (_("lui expression not in range 0..65535"));
10003               s = expr_end;
10004               continue;
10005
10006             case 'a':           /* 26 bit address */
10007               my_getExpression (&offset_expr, s);
10008               s = expr_end;
10009               *offset_reloc = BFD_RELOC_MIPS_JMP;
10010               continue;
10011
10012             case 'N':           /* 3 bit branch condition code */
10013             case 'M':           /* 3 bit compare condition code */
10014               rtype = RTYPE_CCC;
10015               if (ip->insn_mo->pinfo & (FP_D| FP_S))
10016                 rtype |= RTYPE_FCC;
10017               if (!reg_lookup (&s, rtype, &regno))
10018                 break;
10019               if ((strcmp(str + strlen(str) - 3, ".ps") == 0
10020                    || strcmp(str + strlen(str) - 5, "any2f") == 0
10021                    || strcmp(str + strlen(str) - 5, "any2t") == 0)
10022                   && (regno & 1) != 0)
10023                 as_warn (_("Condition code register should be even for %s, was %d"),
10024                          str, regno);
10025               if ((strcmp(str + strlen(str) - 5, "any4f") == 0
10026                    || strcmp(str + strlen(str) - 5, "any4t") == 0)
10027                   && (regno & 3) != 0)
10028                 as_warn (_("Condition code register should be 0 or 4 for %s, was %d"),
10029                          str, regno);
10030               if (*args == 'N')
10031                 INSERT_OPERAND (BCC, *ip, regno);
10032               else
10033                 INSERT_OPERAND (CCC, *ip, regno);
10034               continue;
10035
10036             case 'H':
10037               if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
10038                 s += 2;
10039               if (ISDIGIT (*s))
10040                 {
10041                   c = 0;
10042                   do
10043                     {
10044                       c *= 10;
10045                       c += *s - '0';
10046                       ++s;
10047                     }
10048                   while (ISDIGIT (*s));
10049                 }
10050               else
10051                 c = 8; /* Invalid sel value.  */
10052
10053               if (c > 7)
10054                 as_bad (_("invalid coprocessor sub-selection value (0-7)"));
10055               ip->insn_opcode |= c;
10056               continue;
10057
10058             case 'e':
10059               /* Must be at least one digit.  */
10060               my_getExpression (&imm_expr, s);
10061               check_absolute_expr (ip, &imm_expr);
10062
10063               if ((unsigned long) imm_expr.X_add_number
10064                   > (unsigned long) OP_MASK_VECBYTE)
10065                 {
10066                   as_bad (_("bad byte vector index (%ld)"),
10067                            (long) imm_expr.X_add_number);
10068                   imm_expr.X_add_number = 0;
10069                 }
10070
10071               INSERT_OPERAND (VECBYTE, *ip, imm_expr.X_add_number);
10072               imm_expr.X_op = O_absent;
10073               s = expr_end;
10074               continue;
10075
10076             case '%':
10077               my_getExpression (&imm_expr, s);
10078               check_absolute_expr (ip, &imm_expr);
10079
10080               if ((unsigned long) imm_expr.X_add_number
10081                   > (unsigned long) OP_MASK_VECALIGN)
10082                 {
10083                   as_bad (_("bad byte vector index (%ld)"),
10084                            (long) imm_expr.X_add_number);
10085                   imm_expr.X_add_number = 0;
10086                 }
10087
10088               INSERT_OPERAND (VECALIGN, *ip, imm_expr.X_add_number);
10089               imm_expr.X_op = O_absent;
10090               s = expr_end;
10091               continue;
10092
10093             default:
10094               as_bad (_("bad char = '%c'\n"), *args);
10095               internalError ();
10096             }
10097           break;
10098         }
10099       /* Args don't match.  */
10100       if (insn + 1 < &mips_opcodes[NUMOPCODES] &&
10101           !strcmp (insn->name, insn[1].name))
10102         {
10103           ++insn;
10104           s = argsStart;
10105           insn_error = _("illegal operands");
10106           continue;
10107         }
10108       if (save_c)
10109         *(--argsStart) = save_c;
10110       insn_error = _("illegal operands");
10111       return;
10112     }
10113 }
10114
10115 #define SKIP_SPACE_TABS(S) { while (*(S) == ' ' || *(S) == '\t') ++(S); }
10116
10117 /* This routine assembles an instruction into its binary format when
10118    assembling for the mips16.  As a side effect, it sets one of the
10119    global variables imm_reloc or offset_reloc to the type of
10120    relocation to do if one of the operands is an address expression.
10121    It also sets mips16_small and mips16_ext if the user explicitly
10122    requested a small or extended instruction.  */
10123
10124 static void
10125 mips16_ip (char *str, struct mips_cl_insn *ip)
10126 {
10127   char *s;
10128   const char *args;
10129   struct mips_opcode *insn;
10130   char *argsstart;
10131   unsigned int regno;
10132   unsigned int lastregno = 0;
10133   char *s_reset;
10134   size_t i;
10135
10136   insn_error = NULL;
10137
10138   mips16_small = FALSE;
10139   mips16_ext = FALSE;
10140
10141   for (s = str; ISLOWER (*s); ++s)
10142     ;
10143   switch (*s)
10144     {
10145     case '\0':
10146       break;
10147
10148     case ' ':
10149       *s++ = '\0';
10150       break;
10151
10152     case '.':
10153       if (s[1] == 't' && s[2] == ' ')
10154         {
10155           *s = '\0';
10156           mips16_small = TRUE;
10157           s += 3;
10158           break;
10159         }
10160       else if (s[1] == 'e' && s[2] == ' ')
10161         {
10162           *s = '\0';
10163           mips16_ext = TRUE;
10164           s += 3;
10165           break;
10166         }
10167       /* Fall through.  */
10168     default:
10169       insn_error = _("unknown opcode");
10170       return;
10171     }
10172
10173   if (mips_opts.noautoextend && ! mips16_ext)
10174     mips16_small = TRUE;
10175
10176   if ((insn = (struct mips_opcode *) hash_find (mips16_op_hash, str)) == NULL)
10177     {
10178       insn_error = _("unrecognized opcode");
10179       return;
10180     }
10181
10182   argsstart = s;
10183   for (;;)
10184     {
10185       bfd_boolean ok;
10186
10187       gas_assert (strcmp (insn->name, str) == 0);
10188
10189       ok = is_opcode_valid_16 (insn);
10190       if (! ok)
10191         {
10192           if (insn + 1 < &mips16_opcodes[bfd_mips16_num_opcodes]
10193               && strcmp (insn->name, insn[1].name) == 0)
10194             {
10195               ++insn;
10196               continue;
10197             }
10198           else
10199             {
10200               if (!insn_error)
10201                 {
10202                   static char buf[100];
10203                   sprintf (buf,
10204                            _("opcode not supported on this processor: %s (%s)"),
10205                            mips_cpu_info_from_arch (mips_opts.arch)->name,
10206                            mips_cpu_info_from_isa (mips_opts.isa)->name);
10207                   insn_error = buf;
10208                 }
10209               return;
10210             }
10211         }
10212
10213       create_insn (ip, insn);
10214       imm_expr.X_op = O_absent;
10215       imm_reloc[0] = BFD_RELOC_UNUSED;
10216       imm_reloc[1] = BFD_RELOC_UNUSED;
10217       imm_reloc[2] = BFD_RELOC_UNUSED;
10218       imm2_expr.X_op = O_absent;
10219       offset_expr.X_op = O_absent;
10220       offset_reloc[0] = BFD_RELOC_UNUSED;
10221       offset_reloc[1] = BFD_RELOC_UNUSED;
10222       offset_reloc[2] = BFD_RELOC_UNUSED;
10223       for (args = insn->args; 1; ++args)
10224         {
10225           int c;
10226
10227           if (*s == ' ')
10228             ++s;
10229
10230           /* In this switch statement we call break if we did not find
10231              a match, continue if we did find a match, or return if we
10232              are done.  */
10233
10234           c = *args;
10235           switch (c)
10236             {
10237             case '\0':
10238               if (*s == '\0')
10239                 {
10240                   /* Stuff the immediate value in now, if we can.  */
10241                   if (imm_expr.X_op == O_constant
10242                       && *imm_reloc > BFD_RELOC_UNUSED
10243                       && *imm_reloc != BFD_RELOC_MIPS16_GOT16
10244                       && *imm_reloc != BFD_RELOC_MIPS16_CALL16
10245                       && insn->pinfo != INSN_MACRO)
10246                     {
10247                       valueT tmp;
10248
10249                       switch (*offset_reloc)
10250                         {
10251                           case BFD_RELOC_MIPS16_HI16_S:
10252                             tmp = (imm_expr.X_add_number + 0x8000) >> 16;
10253                             break;
10254
10255                           case BFD_RELOC_MIPS16_HI16:
10256                             tmp = imm_expr.X_add_number >> 16;
10257                             break;
10258
10259                           case BFD_RELOC_MIPS16_LO16:
10260                             tmp = ((imm_expr.X_add_number + 0x8000) & 0xffff)
10261                                   - 0x8000;
10262                             break;
10263
10264                           case BFD_RELOC_UNUSED:
10265                             tmp = imm_expr.X_add_number;
10266                             break;
10267
10268                           default:
10269                             internalError ();
10270                         }
10271                       *offset_reloc = BFD_RELOC_UNUSED;
10272
10273                       mips16_immed (NULL, 0, *imm_reloc - BFD_RELOC_UNUSED,
10274                                     tmp, TRUE, mips16_small,
10275                                     mips16_ext, &ip->insn_opcode,
10276                                     &ip->use_extend, &ip->extend);
10277                       imm_expr.X_op = O_absent;
10278                       *imm_reloc = BFD_RELOC_UNUSED;
10279                     }
10280
10281                   return;
10282                 }
10283               break;
10284
10285             case ',':
10286               if (*s++ == c)
10287                 continue;
10288               s--;
10289               switch (*++args)
10290                 {
10291                 case 'v':
10292                   MIPS16_INSERT_OPERAND (RX, *ip, lastregno);
10293                   continue;
10294                 case 'w':
10295                   MIPS16_INSERT_OPERAND (RY, *ip, lastregno);
10296                   continue;
10297                 }
10298               break;
10299
10300             case '(':
10301             case ')':
10302               if (*s++ == c)
10303                 continue;
10304               break;
10305
10306             case 'v':
10307             case 'w':
10308               if (s[0] != '$')
10309                 {
10310                   if (c == 'v')
10311                     MIPS16_INSERT_OPERAND (RX, *ip, lastregno);
10312                   else
10313                     MIPS16_INSERT_OPERAND (RY, *ip, lastregno);
10314                   ++args;
10315                   continue;
10316                 }
10317               /* Fall through.  */
10318             case 'x':
10319             case 'y':
10320             case 'z':
10321             case 'Z':
10322             case '0':
10323             case 'S':
10324             case 'R':
10325             case 'X':
10326             case 'Y':
10327               s_reset = s;
10328               if (!reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &regno))
10329                 {
10330                   if (c == 'v' || c == 'w')
10331                     {
10332                       if (c == 'v')
10333                         MIPS16_INSERT_OPERAND (RX, *ip, lastregno);
10334                       else
10335                         MIPS16_INSERT_OPERAND (RY, *ip, lastregno);
10336                       ++args;
10337                       continue;
10338                     }
10339                   break;
10340                 }
10341
10342               if (*s == ' ')
10343                 ++s;
10344               if (args[1] != *s)
10345                 {
10346                   if (c == 'v' || c == 'w')
10347                     {
10348                       regno = mips16_to_32_reg_map[lastregno];
10349                       s = s_reset;
10350                       ++args;
10351                     }
10352                 }
10353
10354               switch (c)
10355                 {
10356                 case 'x':
10357                 case 'y':
10358                 case 'z':
10359                 case 'v':
10360                 case 'w':
10361                 case 'Z':
10362                   regno = mips32_to_16_reg_map[regno];
10363                   break;
10364
10365                 case '0':
10366                   if (regno != 0)
10367                     regno = ILLEGAL_REG;
10368                   break;
10369
10370                 case 'S':
10371                   if (regno != SP)
10372                     regno = ILLEGAL_REG;
10373                   break;
10374
10375                 case 'R':
10376                   if (regno != RA)
10377                     regno = ILLEGAL_REG;
10378                   break;
10379
10380                 case 'X':
10381                 case 'Y':
10382                   if (regno == AT && mips_opts.at)
10383                     {
10384                       if (mips_opts.at == ATREG)
10385                         as_warn (_("used $at without \".set noat\""));
10386                       else
10387                         as_warn (_("used $%u with \".set at=$%u\""),
10388                                  regno, mips_opts.at);
10389                     }
10390                   break;
10391
10392                 default:
10393                   internalError ();
10394                 }
10395
10396               if (regno == ILLEGAL_REG)
10397                 break;
10398
10399               switch (c)
10400                 {
10401                 case 'x':
10402                 case 'v':
10403                   MIPS16_INSERT_OPERAND (RX, *ip, regno);
10404                   break;
10405                 case 'y':
10406                 case 'w':
10407                   MIPS16_INSERT_OPERAND (RY, *ip, regno);
10408                   break;
10409                 case 'z':
10410                   MIPS16_INSERT_OPERAND (RZ, *ip, regno);
10411                   break;
10412                 case 'Z':
10413                   MIPS16_INSERT_OPERAND (MOVE32Z, *ip, regno);
10414                 case '0':
10415                 case 'S':
10416                 case 'R':
10417                   break;
10418                 case 'X':
10419                   MIPS16_INSERT_OPERAND (REGR32, *ip, regno);
10420                   break;
10421                 case 'Y':
10422                   regno = ((regno & 7) << 2) | ((regno & 0x18) >> 3);
10423                   MIPS16_INSERT_OPERAND (REG32R, *ip, regno);
10424                   break;
10425                 default:
10426                   internalError ();
10427                 }
10428
10429               lastregno = regno;
10430               continue;
10431
10432             case 'P':
10433               if (strncmp (s, "$pc", 3) == 0)
10434                 {
10435                   s += 3;
10436                   continue;
10437                 }
10438               break;
10439
10440             case '5':
10441             case 'H':
10442             case 'W':
10443             case 'D':
10444             case 'j':
10445             case 'V':
10446             case 'C':
10447             case 'U':
10448             case 'k':
10449             case 'K':
10450               i = my_getSmallExpression (&imm_expr, imm_reloc, s);
10451               if (i > 0)
10452                 {
10453                   if (imm_expr.X_op != O_constant)
10454                     {
10455                       mips16_ext = TRUE;
10456                       ip->use_extend = TRUE;
10457                       ip->extend = 0;
10458                     }
10459                   else
10460                     {
10461                       /* We need to relax this instruction.  */
10462                       *offset_reloc = *imm_reloc;
10463                       *imm_reloc = (int) BFD_RELOC_UNUSED + c;
10464                     }
10465                   s = expr_end;
10466                   continue;
10467                 }
10468               *imm_reloc = BFD_RELOC_UNUSED;
10469               /* Fall through.  */
10470             case '<':
10471             case '>':
10472             case '[':
10473             case ']':
10474             case '4':
10475             case '8':
10476               my_getExpression (&imm_expr, s);
10477               if (imm_expr.X_op == O_register)
10478                 {
10479                   /* What we thought was an expression turned out to
10480                      be a register.  */
10481
10482                   if (s[0] == '(' && args[1] == '(')
10483                     {
10484                       /* It looks like the expression was omitted
10485                          before a register indirection, which means
10486                          that the expression is implicitly zero.  We
10487                          still set up imm_expr, so that we handle
10488                          explicit extensions correctly.  */
10489                       imm_expr.X_op = O_constant;
10490                       imm_expr.X_add_number = 0;
10491                       *imm_reloc = (int) BFD_RELOC_UNUSED + c;
10492                       continue;
10493                     }
10494
10495                   break;
10496                 }
10497
10498               /* We need to relax this instruction.  */
10499               *imm_reloc = (int) BFD_RELOC_UNUSED + c;
10500               s = expr_end;
10501               continue;
10502
10503             case 'p':
10504             case 'q':
10505             case 'A':
10506             case 'B':
10507             case 'E':
10508               /* We use offset_reloc rather than imm_reloc for the PC
10509                  relative operands.  This lets macros with both
10510                  immediate and address operands work correctly.  */
10511               my_getExpression (&offset_expr, s);
10512
10513               if (offset_expr.X_op == O_register)
10514                 break;
10515
10516               /* We need to relax this instruction.  */
10517               *offset_reloc = (int) BFD_RELOC_UNUSED + c;
10518               s = expr_end;
10519               continue;
10520
10521             case '6':           /* break code */
10522               my_getExpression (&imm_expr, s);
10523               check_absolute_expr (ip, &imm_expr);
10524               if ((unsigned long) imm_expr.X_add_number > 63)
10525                 as_warn (_("Invalid value for `%s' (%lu)"),
10526                          ip->insn_mo->name,
10527                          (unsigned long) imm_expr.X_add_number);
10528               MIPS16_INSERT_OPERAND (IMM6, *ip, imm_expr.X_add_number);
10529               imm_expr.X_op = O_absent;
10530               s = expr_end;
10531               continue;
10532
10533             case 'a':           /* 26 bit address */
10534               my_getExpression (&offset_expr, s);
10535               s = expr_end;
10536               *offset_reloc = BFD_RELOC_MIPS16_JMP;
10537               ip->insn_opcode <<= 16;
10538               continue;
10539
10540             case 'l':           /* register list for entry macro */
10541             case 'L':           /* register list for exit macro */
10542               {
10543                 int mask;
10544
10545                 if (c == 'l')
10546                   mask = 0;
10547                 else
10548                   mask = 7 << 3;
10549                 while (*s != '\0')
10550                   {
10551                     unsigned int freg, reg1, reg2;
10552
10553                     while (*s == ' ' || *s == ',')
10554                       ++s;
10555                     if (reg_lookup (&s, RTYPE_GP | RTYPE_NUM, &reg1))
10556                       freg = 0;
10557                     else if (reg_lookup (&s, RTYPE_FPU, &reg1))
10558                       freg = 1;
10559                     else
10560                       {
10561                         as_bad (_("can't parse register list"));
10562                         break;
10563                       }
10564                     if (*s == ' ')
10565                       ++s;
10566                     if (*s != '-')
10567                       reg2 = reg1;
10568                     else
10569                       {
10570                         ++s;
10571                         if (!reg_lookup (&s, freg ? RTYPE_FPU 
10572                                          : (RTYPE_GP | RTYPE_NUM), &reg2))
10573                           {
10574                             as_bad (_("invalid register list"));
10575                             break;
10576                           }
10577                       }
10578                     if (freg && reg1 == 0 && reg2 == 0 && c == 'L')
10579                       {
10580                         mask &= ~ (7 << 3);
10581                         mask |= 5 << 3;
10582                       }
10583                     else if (freg && reg1 == 0 && reg2 == 1 && c == 'L')
10584                       {
10585                         mask &= ~ (7 << 3);
10586                         mask |= 6 << 3;
10587                       }
10588                     else if (reg1 == 4 && reg2 >= 4 && reg2 <= 7 && c != 'L')
10589                       mask |= (reg2 - 3) << 3;
10590                     else if (reg1 == 16 && reg2 >= 16 && reg2 <= 17)
10591                       mask |= (reg2 - 15) << 1;
10592                     else if (reg1 == RA && reg2 == RA)
10593                       mask |= 1;
10594                     else
10595                       {
10596                         as_bad (_("invalid register list"));
10597                         break;
10598                       }
10599                   }
10600                 /* The mask is filled in in the opcode table for the
10601                    benefit of the disassembler.  We remove it before
10602                    applying the actual mask.  */
10603                 ip->insn_opcode &= ~ ((7 << 3) << MIPS16OP_SH_IMM6);
10604                 ip->insn_opcode |= mask << MIPS16OP_SH_IMM6;
10605               }
10606             continue;
10607
10608             case 'm':           /* Register list for save insn.  */
10609             case 'M':           /* Register list for restore insn.  */
10610               {
10611                 int opcode = 0;
10612                 int framesz = 0, seen_framesz = 0;
10613                 int nargs = 0, statics = 0, sregs = 0;
10614
10615                 while (*s != '\0')
10616                   {
10617                     unsigned int reg1, reg2;
10618
10619                     SKIP_SPACE_TABS (s);
10620                     while (*s == ',')
10621                       ++s;
10622                     SKIP_SPACE_TABS (s);
10623
10624                     my_getExpression (&imm_expr, s);
10625                     if (imm_expr.X_op == O_constant)
10626                       {
10627                         /* Handle the frame size.  */
10628                         if (seen_framesz)
10629                           {
10630                             as_bad (_("more than one frame size in list"));
10631                             break;
10632                           }
10633                         seen_framesz = 1;
10634                         framesz = imm_expr.X_add_number;
10635                         imm_expr.X_op = O_absent;
10636                         s = expr_end;
10637                         continue;
10638                       }
10639
10640                     if (! reg_lookup (&s, RTYPE_GP | RTYPE_NUM, &reg1))
10641                       {
10642                         as_bad (_("can't parse register list"));
10643                         break;
10644                       }
10645
10646                     while (*s == ' ')
10647                       ++s;
10648
10649                     if (*s != '-')
10650                       reg2 = reg1;
10651                     else
10652                       {
10653                         ++s;
10654                         if (! reg_lookup (&s, RTYPE_GP | RTYPE_NUM, &reg2)
10655                             || reg2 < reg1)
10656                           {
10657                             as_bad (_("can't parse register list"));
10658                             break;
10659                           }
10660                       }
10661
10662                     while (reg1 <= reg2)
10663                       {
10664                         if (reg1 >= 4 && reg1 <= 7)
10665                           {
10666                             if (!seen_framesz)
10667                                 /* args $a0-$a3 */
10668                                 nargs |= 1 << (reg1 - 4);
10669                             else
10670                                 /* statics $a0-$a3 */
10671                                 statics |= 1 << (reg1 - 4);
10672                           }
10673                         else if ((reg1 >= 16 && reg1 <= 23) || reg1 == 30)
10674                           {
10675                             /* $s0-$s8 */
10676                             sregs |= 1 << ((reg1 == 30) ? 8 : (reg1 - 16));
10677                           }
10678                         else if (reg1 == 31)
10679                           {
10680                             /* Add $ra to insn.  */
10681                             opcode |= 0x40;
10682                           }
10683                         else
10684                           {
10685                             as_bad (_("unexpected register in list"));
10686                             break;
10687                           }
10688                         if (++reg1 == 24)
10689                           reg1 = 30;
10690                       }
10691                   }
10692
10693                 /* Encode args/statics combination.  */
10694                 if (nargs & statics)
10695                   as_bad (_("arg/static registers overlap"));
10696                 else if (nargs == 0xf)
10697                   /* All $a0-$a3 are args.  */
10698                   opcode |= MIPS16_ALL_ARGS << 16;
10699                 else if (statics == 0xf)
10700                   /* All $a0-$a3 are statics.  */
10701                   opcode |= MIPS16_ALL_STATICS << 16;
10702                 else 
10703                   {
10704                     int narg = 0, nstat = 0;
10705
10706                     /* Count arg registers.  */
10707                     while (nargs & 0x1)
10708                       {
10709                         nargs >>= 1;
10710                         narg++;
10711                       }
10712                     if (nargs != 0)
10713                       as_bad (_("invalid arg register list"));
10714
10715                     /* Count static registers.  */
10716                     while (statics & 0x8)
10717                       {
10718                         statics = (statics << 1) & 0xf;
10719                         nstat++;
10720                       }
10721                     if (statics != 0) 
10722                       as_bad (_("invalid static register list"));
10723
10724                     /* Encode args/statics.  */
10725                     opcode |= ((narg << 2) | nstat) << 16;
10726                   }
10727
10728                 /* Encode $s0/$s1.  */
10729                 if (sregs & (1 << 0))           /* $s0 */
10730                   opcode |= 0x20;
10731                 if (sregs & (1 << 1))           /* $s1 */
10732                   opcode |= 0x10;
10733                 sregs >>= 2;
10734
10735                 if (sregs != 0)
10736                   {
10737                     /* Count regs $s2-$s8.  */
10738                     int nsreg = 0;
10739                     while (sregs & 1)
10740                       {
10741                         sregs >>= 1;
10742                         nsreg++;
10743                       }
10744                     if (sregs != 0)
10745                       as_bad (_("invalid static register list"));
10746                     /* Encode $s2-$s8. */
10747                     opcode |= nsreg << 24;
10748                   }
10749
10750                 /* Encode frame size.  */
10751                 if (!seen_framesz)
10752                   as_bad (_("missing frame size"));
10753                 else if ((framesz & 7) != 0 || framesz < 0
10754                          || framesz > 0xff * 8)
10755                   as_bad (_("invalid frame size"));
10756                 else if (framesz != 128 || (opcode >> 16) != 0)
10757                   {
10758                     framesz /= 8;
10759                     opcode |= (((framesz & 0xf0) << 16)
10760                              | (framesz & 0x0f));
10761                   }
10762
10763                 /* Finally build the instruction.  */
10764                 if ((opcode >> 16) != 0 || framesz == 0)
10765                   {
10766                     ip->use_extend = TRUE;
10767                     ip->extend = opcode >> 16;
10768                   }
10769                 ip->insn_opcode |= opcode & 0x7f;
10770               }
10771             continue;
10772
10773             case 'e':           /* extend code */
10774               my_getExpression (&imm_expr, s);
10775               check_absolute_expr (ip, &imm_expr);
10776               if ((unsigned long) imm_expr.X_add_number > 0x7ff)
10777                 {
10778                   as_warn (_("Invalid value for `%s' (%lu)"),
10779                            ip->insn_mo->name,
10780                            (unsigned long) imm_expr.X_add_number);
10781                   imm_expr.X_add_number &= 0x7ff;
10782                 }
10783               ip->insn_opcode |= imm_expr.X_add_number;
10784               imm_expr.X_op = O_absent;
10785               s = expr_end;
10786               continue;
10787
10788             default:
10789               internalError ();
10790             }
10791           break;
10792         }
10793
10794       /* Args don't match.  */
10795       if (insn + 1 < &mips16_opcodes[bfd_mips16_num_opcodes] &&
10796           strcmp (insn->name, insn[1].name) == 0)
10797         {
10798           ++insn;
10799           s = argsstart;
10800           continue;
10801         }
10802
10803       insn_error = _("illegal operands");
10804
10805       return;
10806     }
10807 }
10808
10809 /* This structure holds information we know about a mips16 immediate
10810    argument type.  */
10811
10812 struct mips16_immed_operand
10813 {
10814   /* The type code used in the argument string in the opcode table.  */
10815   int type;
10816   /* The number of bits in the short form of the opcode.  */
10817   int nbits;
10818   /* The number of bits in the extended form of the opcode.  */
10819   int extbits;
10820   /* The amount by which the short form is shifted when it is used;
10821      for example, the sw instruction has a shift count of 2.  */
10822   int shift;
10823   /* The amount by which the short form is shifted when it is stored
10824      into the instruction code.  */
10825   int op_shift;
10826   /* Non-zero if the short form is unsigned.  */
10827   int unsp;
10828   /* Non-zero if the extended form is unsigned.  */
10829   int extu;
10830   /* Non-zero if the value is PC relative.  */
10831   int pcrel;
10832 };
10833
10834 /* The mips16 immediate operand types.  */
10835
10836 static const struct mips16_immed_operand mips16_immed_operands[] =
10837 {
10838   { '<',  3,  5, 0, MIPS16OP_SH_RZ,   1, 1, 0 },
10839   { '>',  3,  5, 0, MIPS16OP_SH_RX,   1, 1, 0 },
10840   { '[',  3,  6, 0, MIPS16OP_SH_RZ,   1, 1, 0 },
10841   { ']',  3,  6, 0, MIPS16OP_SH_RX,   1, 1, 0 },
10842   { '4',  4, 15, 0, MIPS16OP_SH_IMM4, 0, 0, 0 },
10843   { '5',  5, 16, 0, MIPS16OP_SH_IMM5, 1, 0, 0 },
10844   { 'H',  5, 16, 1, MIPS16OP_SH_IMM5, 1, 0, 0 },
10845   { 'W',  5, 16, 2, MIPS16OP_SH_IMM5, 1, 0, 0 },
10846   { 'D',  5, 16, 3, MIPS16OP_SH_IMM5, 1, 0, 0 },
10847   { 'j',  5, 16, 0, MIPS16OP_SH_IMM5, 0, 0, 0 },
10848   { '8',  8, 16, 0, MIPS16OP_SH_IMM8, 1, 0, 0 },
10849   { 'V',  8, 16, 2, MIPS16OP_SH_IMM8, 1, 0, 0 },
10850   { 'C',  8, 16, 3, MIPS16OP_SH_IMM8, 1, 0, 0 },
10851   { 'U',  8, 16, 0, MIPS16OP_SH_IMM8, 1, 1, 0 },
10852   { 'k',  8, 16, 0, MIPS16OP_SH_IMM8, 0, 0, 0 },
10853   { 'K',  8, 16, 3, MIPS16OP_SH_IMM8, 0, 0, 0 },
10854   { 'p',  8, 16, 0, MIPS16OP_SH_IMM8, 0, 0, 1 },
10855   { 'q', 11, 16, 0, MIPS16OP_SH_IMM8, 0, 0, 1 },
10856   { 'A',  8, 16, 2, MIPS16OP_SH_IMM8, 1, 0, 1 },
10857   { 'B',  5, 16, 3, MIPS16OP_SH_IMM5, 1, 0, 1 },
10858   { 'E',  5, 16, 2, MIPS16OP_SH_IMM5, 1, 0, 1 }
10859 };
10860
10861 #define MIPS16_NUM_IMMED \
10862   (sizeof mips16_immed_operands / sizeof mips16_immed_operands[0])
10863
10864 /* Handle a mips16 instruction with an immediate value.  This or's the
10865    small immediate value into *INSN.  It sets *USE_EXTEND to indicate
10866    whether an extended value is needed; if one is needed, it sets
10867    *EXTEND to the value.  The argument type is TYPE.  The value is VAL.
10868    If SMALL is true, an unextended opcode was explicitly requested.
10869    If EXT is true, an extended opcode was explicitly requested.  If
10870    WARN is true, warn if EXT does not match reality.  */
10871
10872 static void
10873 mips16_immed (char *file, unsigned int line, int type, offsetT val,
10874               bfd_boolean warn, bfd_boolean small, bfd_boolean ext,
10875               unsigned long *insn, bfd_boolean *use_extend,
10876               unsigned short *extend)
10877 {
10878   const struct mips16_immed_operand *op;
10879   int mintiny, maxtiny;
10880   bfd_boolean needext;
10881
10882   op = mips16_immed_operands;
10883   while (op->type != type)
10884     {
10885       ++op;
10886       gas_assert (op < mips16_immed_operands + MIPS16_NUM_IMMED);
10887     }
10888
10889   if (op->unsp)
10890     {
10891       if (type == '<' || type == '>' || type == '[' || type == ']')
10892         {
10893           mintiny = 1;
10894           maxtiny = 1 << op->nbits;
10895         }
10896       else
10897         {
10898           mintiny = 0;
10899           maxtiny = (1 << op->nbits) - 1;
10900         }
10901     }
10902   else
10903     {
10904       mintiny = - (1 << (op->nbits - 1));
10905       maxtiny = (1 << (op->nbits - 1)) - 1;
10906     }
10907
10908   /* Branch offsets have an implicit 0 in the lowest bit.  */
10909   if (type == 'p' || type == 'q')
10910     val /= 2;
10911
10912   if ((val & ((1 << op->shift) - 1)) != 0
10913       || val < (mintiny << op->shift)
10914       || val > (maxtiny << op->shift))
10915     needext = TRUE;
10916   else
10917     needext = FALSE;
10918
10919   if (warn && ext && ! needext)
10920     as_warn_where (file, line,
10921                    _("extended operand requested but not required"));
10922   if (small && needext)
10923     as_bad_where (file, line, _("invalid unextended operand value"));
10924
10925   if (small || (! ext && ! needext))
10926     {
10927       int insnval;
10928
10929       *use_extend = FALSE;
10930       insnval = ((val >> op->shift) & ((1 << op->nbits) - 1));
10931       insnval <<= op->op_shift;
10932       *insn |= insnval;
10933     }
10934   else
10935     {
10936       long minext, maxext;
10937       int extval;
10938
10939       if (op->extu)
10940         {
10941           minext = 0;
10942           maxext = (1 << op->extbits) - 1;
10943         }
10944       else
10945         {
10946           minext = - (1 << (op->extbits - 1));
10947           maxext = (1 << (op->extbits - 1)) - 1;
10948         }
10949       if (val < minext || val > maxext)
10950         as_bad_where (file, line,
10951                       _("operand value out of range for instruction"));
10952
10953       *use_extend = TRUE;
10954       if (op->extbits == 16)
10955         {
10956           extval = ((val >> 11) & 0x1f) | (val & 0x7e0);
10957           val &= 0x1f;
10958         }
10959       else if (op->extbits == 15)
10960         {
10961           extval = ((val >> 11) & 0xf) | (val & 0x7f0);
10962           val &= 0xf;
10963         }
10964       else
10965         {
10966           extval = ((val & 0x1f) << 6) | (val & 0x20);
10967           val = 0;
10968         }
10969
10970       *extend = (unsigned short) extval;
10971       *insn |= val;
10972     }
10973 }
10974 \f
10975 struct percent_op_match
10976 {
10977   const char *str;
10978   bfd_reloc_code_real_type reloc;
10979 };
10980
10981 static const struct percent_op_match mips_percent_op[] =
10982 {
10983   {"%lo", BFD_RELOC_LO16},
10984 #ifdef OBJ_ELF
10985   {"%call_hi", BFD_RELOC_MIPS_CALL_HI16},
10986   {"%call_lo", BFD_RELOC_MIPS_CALL_LO16},
10987   {"%call16", BFD_RELOC_MIPS_CALL16},
10988   {"%got_disp", BFD_RELOC_MIPS_GOT_DISP},
10989   {"%got_page", BFD_RELOC_MIPS_GOT_PAGE},
10990   {"%got_ofst", BFD_RELOC_MIPS_GOT_OFST},
10991   {"%got_hi", BFD_RELOC_MIPS_GOT_HI16},
10992   {"%got_lo", BFD_RELOC_MIPS_GOT_LO16},
10993   {"%got", BFD_RELOC_MIPS_GOT16},
10994   {"%gp_rel", BFD_RELOC_GPREL16},
10995   {"%half", BFD_RELOC_16},
10996   {"%highest", BFD_RELOC_MIPS_HIGHEST},
10997   {"%higher", BFD_RELOC_MIPS_HIGHER},
10998   {"%neg", BFD_RELOC_MIPS_SUB},
10999   {"%tlsgd", BFD_RELOC_MIPS_TLS_GD},
11000   {"%tlsldm", BFD_RELOC_MIPS_TLS_LDM},
11001   {"%dtprel_hi", BFD_RELOC_MIPS_TLS_DTPREL_HI16},
11002   {"%dtprel_lo", BFD_RELOC_MIPS_TLS_DTPREL_LO16},
11003   {"%tprel_hi", BFD_RELOC_MIPS_TLS_TPREL_HI16},
11004   {"%tprel_lo", BFD_RELOC_MIPS_TLS_TPREL_LO16},
11005   {"%gottprel", BFD_RELOC_MIPS_TLS_GOTTPREL},
11006 #endif
11007   {"%hi", BFD_RELOC_HI16_S}
11008 };
11009
11010 static const struct percent_op_match mips16_percent_op[] =
11011 {
11012   {"%lo", BFD_RELOC_MIPS16_LO16},
11013   {"%gprel", BFD_RELOC_MIPS16_GPREL},
11014   {"%got", BFD_RELOC_MIPS16_GOT16},
11015   {"%call16", BFD_RELOC_MIPS16_CALL16},
11016   {"%hi", BFD_RELOC_MIPS16_HI16_S}
11017 };
11018
11019
11020 /* Return true if *STR points to a relocation operator.  When returning true,
11021    move *STR over the operator and store its relocation code in *RELOC.
11022    Leave both *STR and *RELOC alone when returning false.  */
11023
11024 static bfd_boolean
11025 parse_relocation (char **str, bfd_reloc_code_real_type *reloc)
11026 {
11027   const struct percent_op_match *percent_op;
11028   size_t limit, i;
11029
11030   if (mips_opts.mips16)
11031     {
11032       percent_op = mips16_percent_op;
11033       limit = ARRAY_SIZE (mips16_percent_op);
11034     }
11035   else
11036     {
11037       percent_op = mips_percent_op;
11038       limit = ARRAY_SIZE (mips_percent_op);
11039     }
11040
11041   for (i = 0; i < limit; i++)
11042     if (strncasecmp (*str, percent_op[i].str, strlen (percent_op[i].str)) == 0)
11043       {
11044         int len = strlen (percent_op[i].str);
11045
11046         if (!ISSPACE ((*str)[len]) && (*str)[len] != '(')
11047           continue;
11048
11049         *str += strlen (percent_op[i].str);
11050         *reloc = percent_op[i].reloc;
11051
11052         /* Check whether the output BFD supports this relocation.
11053            If not, issue an error and fall back on something safe.  */
11054         if (!bfd_reloc_type_lookup (stdoutput, percent_op[i].reloc))
11055           {
11056             as_bad (_("relocation %s isn't supported by the current ABI"),
11057                     percent_op[i].str);
11058             *reloc = BFD_RELOC_UNUSED;
11059           }
11060         return TRUE;
11061       }
11062   return FALSE;
11063 }
11064
11065
11066 /* Parse string STR as a 16-bit relocatable operand.  Store the
11067    expression in *EP and the relocations in the array starting
11068    at RELOC.  Return the number of relocation operators used.
11069
11070    On exit, EXPR_END points to the first character after the expression.  */
11071
11072 static size_t
11073 my_getSmallExpression (expressionS *ep, bfd_reloc_code_real_type *reloc,
11074                        char *str)
11075 {
11076   bfd_reloc_code_real_type reversed_reloc[3];
11077   size_t reloc_index, i;
11078   int crux_depth, str_depth;
11079   char *crux;
11080
11081   /* Search for the start of the main expression, recoding relocations
11082      in REVERSED_RELOC.  End the loop with CRUX pointing to the start
11083      of the main expression and with CRUX_DEPTH containing the number
11084      of open brackets at that point.  */
11085   reloc_index = -1;
11086   str_depth = 0;
11087   do
11088     {
11089       reloc_index++;
11090       crux = str;
11091       crux_depth = str_depth;
11092
11093       /* Skip over whitespace and brackets, keeping count of the number
11094          of brackets.  */
11095       while (*str == ' ' || *str == '\t' || *str == '(')
11096         if (*str++ == '(')
11097           str_depth++;
11098     }
11099   while (*str == '%'
11100          && reloc_index < (HAVE_NEWABI ? 3 : 1)
11101          && parse_relocation (&str, &reversed_reloc[reloc_index]));
11102
11103   my_getExpression (ep, crux);
11104   str = expr_end;
11105
11106   /* Match every open bracket.  */
11107   while (crux_depth > 0 && (*str == ')' || *str == ' ' || *str == '\t'))
11108     if (*str++ == ')')
11109       crux_depth--;
11110
11111   if (crux_depth > 0)
11112     as_bad (_("unclosed '('"));
11113
11114   expr_end = str;
11115
11116   if (reloc_index != 0)
11117     {
11118       prev_reloc_op_frag = frag_now;
11119       for (i = 0; i < reloc_index; i++)
11120         reloc[i] = reversed_reloc[reloc_index - 1 - i];
11121     }
11122
11123   return reloc_index;
11124 }
11125
11126 static void
11127 my_getExpression (expressionS *ep, char *str)
11128 {
11129   char *save_in;
11130   valueT val;
11131
11132   save_in = input_line_pointer;
11133   input_line_pointer = str;
11134   expression (ep);
11135   expr_end = input_line_pointer;
11136   input_line_pointer = save_in;
11137
11138   /* If we are in mips16 mode, and this is an expression based on `.',
11139      then we bump the value of the symbol by 1 since that is how other
11140      text symbols are handled.  We don't bother to handle complex
11141      expressions, just `.' plus or minus a constant.  */
11142   if (mips_opts.mips16
11143       && ep->X_op == O_symbol
11144       && strcmp (S_GET_NAME (ep->X_add_symbol), FAKE_LABEL_NAME) == 0
11145       && S_GET_SEGMENT (ep->X_add_symbol) == now_seg
11146       && symbol_get_frag (ep->X_add_symbol) == frag_now
11147       && symbol_constant_p (ep->X_add_symbol)
11148       && (val = S_GET_VALUE (ep->X_add_symbol)) == frag_now_fix ())
11149     S_SET_VALUE (ep->X_add_symbol, val + 1);
11150 }
11151
11152 char *
11153 md_atof (int type, char *litP, int *sizeP)
11154 {
11155   return ieee_md_atof (type, litP, sizeP, target_big_endian);
11156 }
11157
11158 void
11159 md_number_to_chars (char *buf, valueT val, int n)
11160 {
11161   if (target_big_endian)
11162     number_to_chars_bigendian (buf, val, n);
11163   else
11164     number_to_chars_littleendian (buf, val, n);
11165 }
11166 \f
11167 #ifdef OBJ_ELF
11168 static int support_64bit_objects(void)
11169 {
11170   const char **list, **l;
11171   int yes;
11172
11173   list = bfd_target_list ();
11174   for (l = list; *l != NULL; l++)
11175 #ifdef TE_TMIPS
11176     /* This is traditional mips */
11177     if (strcmp (*l, "elf64-tradbigmips") == 0
11178         || strcmp (*l, "elf64-tradlittlemips") == 0)
11179 #else
11180     if (strcmp (*l, "elf64-bigmips") == 0
11181         || strcmp (*l, "elf64-littlemips") == 0)
11182 #endif
11183       break;
11184   yes = (*l != NULL);
11185   free (list);
11186   return yes;
11187 }
11188 #endif /* OBJ_ELF */
11189
11190 const char *md_shortopts = "O::g::G:";
11191
11192 enum options
11193   {
11194     OPTION_MARCH = OPTION_MD_BASE,
11195     OPTION_MTUNE,
11196     OPTION_MIPS1,
11197     OPTION_MIPS2,
11198     OPTION_MIPS3,
11199     OPTION_MIPS4,
11200     OPTION_MIPS5,
11201     OPTION_MIPS32,
11202     OPTION_MIPS64,
11203     OPTION_MIPS32R2,
11204     OPTION_MIPS64R2,
11205     OPTION_MIPS16,
11206     OPTION_NO_MIPS16,
11207     OPTION_MIPS3D,
11208     OPTION_NO_MIPS3D,
11209     OPTION_MDMX,
11210     OPTION_NO_MDMX,
11211     OPTION_DSP,
11212     OPTION_NO_DSP,
11213     OPTION_MT,
11214     OPTION_NO_MT,
11215     OPTION_SMARTMIPS,
11216     OPTION_NO_SMARTMIPS,
11217     OPTION_DSPR2,
11218     OPTION_NO_DSPR2,
11219     OPTION_COMPAT_ARCH_BASE,
11220     OPTION_M4650,
11221     OPTION_NO_M4650,
11222     OPTION_M4010,
11223     OPTION_NO_M4010,
11224     OPTION_M4100,
11225     OPTION_NO_M4100,
11226     OPTION_M3900,
11227     OPTION_NO_M3900,
11228     OPTION_M7000_HILO_FIX,
11229     OPTION_MNO_7000_HILO_FIX, 
11230     OPTION_FIX_24K,
11231     OPTION_NO_FIX_24K,
11232     OPTION_FIX_LOONGSON2F_JUMP,
11233     OPTION_NO_FIX_LOONGSON2F_JUMP,
11234     OPTION_FIX_LOONGSON2F_NOP,
11235     OPTION_NO_FIX_LOONGSON2F_NOP,
11236     OPTION_FIX_VR4120,
11237     OPTION_NO_FIX_VR4120,
11238     OPTION_FIX_VR4130,
11239     OPTION_NO_FIX_VR4130,
11240     OPTION_FIX_CN63XXP1,
11241     OPTION_NO_FIX_CN63XXP1,
11242     OPTION_TRAP,
11243     OPTION_BREAK,
11244     OPTION_EB,
11245     OPTION_EL,
11246     OPTION_FP32,
11247     OPTION_GP32,
11248     OPTION_CONSTRUCT_FLOATS,
11249     OPTION_NO_CONSTRUCT_FLOATS,
11250     OPTION_FP64,
11251     OPTION_GP64,
11252     OPTION_RELAX_BRANCH,
11253     OPTION_NO_RELAX_BRANCH,
11254     OPTION_MSHARED,
11255     OPTION_MNO_SHARED,
11256     OPTION_MSYM32,
11257     OPTION_MNO_SYM32,
11258     OPTION_SOFT_FLOAT,
11259     OPTION_HARD_FLOAT,
11260     OPTION_SINGLE_FLOAT,
11261     OPTION_DOUBLE_FLOAT,
11262     OPTION_32,
11263 #ifdef OBJ_ELF
11264     OPTION_CALL_SHARED,
11265     OPTION_CALL_NONPIC,
11266     OPTION_NON_SHARED,
11267     OPTION_XGOT,
11268     OPTION_MABI,
11269     OPTION_N32,
11270     OPTION_64,
11271     OPTION_MDEBUG,
11272     OPTION_NO_MDEBUG,
11273     OPTION_PDR,
11274     OPTION_NO_PDR,
11275     OPTION_MVXWORKS_PIC,
11276 #endif /* OBJ_ELF */
11277     OPTION_END_OF_ENUM    
11278   };
11279   
11280 struct option md_longopts[] =
11281 {
11282   /* Options which specify architecture.  */
11283   {"march", required_argument, NULL, OPTION_MARCH},
11284   {"mtune", required_argument, NULL, OPTION_MTUNE},
11285   {"mips0", no_argument, NULL, OPTION_MIPS1},
11286   {"mips1", no_argument, NULL, OPTION_MIPS1},
11287   {"mips2", no_argument, NULL, OPTION_MIPS2},
11288   {"mips3", no_argument, NULL, OPTION_MIPS3},
11289   {"mips4", no_argument, NULL, OPTION_MIPS4},
11290   {"mips5", no_argument, NULL, OPTION_MIPS5},
11291   {"mips32", no_argument, NULL, OPTION_MIPS32},
11292   {"mips64", no_argument, NULL, OPTION_MIPS64},
11293   {"mips32r2", no_argument, NULL, OPTION_MIPS32R2},
11294   {"mips64r2", no_argument, NULL, OPTION_MIPS64R2},
11295
11296   /* Options which specify Application Specific Extensions (ASEs).  */
11297   {"mips16", no_argument, NULL, OPTION_MIPS16},
11298   {"no-mips16", no_argument, NULL, OPTION_NO_MIPS16},
11299   {"mips3d", no_argument, NULL, OPTION_MIPS3D},
11300   {"no-mips3d", no_argument, NULL, OPTION_NO_MIPS3D},
11301   {"mdmx", no_argument, NULL, OPTION_MDMX},
11302   {"no-mdmx", no_argument, NULL, OPTION_NO_MDMX},
11303   {"mdsp", no_argument, NULL, OPTION_DSP},
11304   {"mno-dsp", no_argument, NULL, OPTION_NO_DSP},
11305   {"mmt", no_argument, NULL, OPTION_MT},
11306   {"mno-mt", no_argument, NULL, OPTION_NO_MT},
11307   {"msmartmips", no_argument, NULL, OPTION_SMARTMIPS},
11308   {"mno-smartmips", no_argument, NULL, OPTION_NO_SMARTMIPS},
11309   {"mdspr2", no_argument, NULL, OPTION_DSPR2},
11310   {"mno-dspr2", no_argument, NULL, OPTION_NO_DSPR2},
11311
11312   /* Old-style architecture options.  Don't add more of these.  */
11313   {"m4650", no_argument, NULL, OPTION_M4650},
11314   {"no-m4650", no_argument, NULL, OPTION_NO_M4650},
11315   {"m4010", no_argument, NULL, OPTION_M4010},
11316   {"no-m4010", no_argument, NULL, OPTION_NO_M4010},
11317   {"m4100", no_argument, NULL, OPTION_M4100},
11318   {"no-m4100", no_argument, NULL, OPTION_NO_M4100},
11319   {"m3900", no_argument, NULL, OPTION_M3900},
11320   {"no-m3900", no_argument, NULL, OPTION_NO_M3900},
11321
11322   /* Options which enable bug fixes.  */
11323   {"mfix7000", no_argument, NULL, OPTION_M7000_HILO_FIX},
11324   {"no-fix-7000", no_argument, NULL, OPTION_MNO_7000_HILO_FIX},
11325   {"mno-fix7000", no_argument, NULL, OPTION_MNO_7000_HILO_FIX},
11326   {"mfix-loongson2f-jump", no_argument, NULL, OPTION_FIX_LOONGSON2F_JUMP},
11327   {"mno-fix-loongson2f-jump", no_argument, NULL, OPTION_NO_FIX_LOONGSON2F_JUMP},
11328   {"mfix-loongson2f-nop", no_argument, NULL, OPTION_FIX_LOONGSON2F_NOP},
11329   {"mno-fix-loongson2f-nop", no_argument, NULL, OPTION_NO_FIX_LOONGSON2F_NOP},
11330   {"mfix-vr4120",    no_argument, NULL, OPTION_FIX_VR4120},
11331   {"mno-fix-vr4120", no_argument, NULL, OPTION_NO_FIX_VR4120},
11332   {"mfix-vr4130",    no_argument, NULL, OPTION_FIX_VR4130},
11333   {"mno-fix-vr4130", no_argument, NULL, OPTION_NO_FIX_VR4130},
11334   {"mfix-24k",    no_argument, NULL, OPTION_FIX_24K},
11335   {"mno-fix-24k", no_argument, NULL, OPTION_NO_FIX_24K},
11336   {"mfix-cn63xxp1", no_argument, NULL, OPTION_FIX_CN63XXP1},
11337   {"mno-fix-cn63xxp1", no_argument, NULL, OPTION_NO_FIX_CN63XXP1},
11338
11339   /* Miscellaneous options.  */
11340   {"trap", no_argument, NULL, OPTION_TRAP},
11341   {"no-break", no_argument, NULL, OPTION_TRAP},
11342   {"break", no_argument, NULL, OPTION_BREAK},
11343   {"no-trap", no_argument, NULL, OPTION_BREAK},
11344   {"EB", no_argument, NULL, OPTION_EB},
11345   {"EL", no_argument, NULL, OPTION_EL},
11346   {"mfp32", no_argument, NULL, OPTION_FP32},
11347   {"mgp32", no_argument, NULL, OPTION_GP32},
11348   {"construct-floats", no_argument, NULL, OPTION_CONSTRUCT_FLOATS},
11349   {"no-construct-floats", no_argument, NULL, OPTION_NO_CONSTRUCT_FLOATS},
11350   {"mfp64", no_argument, NULL, OPTION_FP64},
11351   {"mgp64", no_argument, NULL, OPTION_GP64},
11352   {"relax-branch", no_argument, NULL, OPTION_RELAX_BRANCH},
11353   {"no-relax-branch", no_argument, NULL, OPTION_NO_RELAX_BRANCH},
11354   {"mshared", no_argument, NULL, OPTION_MSHARED},
11355   {"mno-shared", no_argument, NULL, OPTION_MNO_SHARED},
11356   {"msym32", no_argument, NULL, OPTION_MSYM32},
11357   {"mno-sym32", no_argument, NULL, OPTION_MNO_SYM32},
11358   {"msoft-float", no_argument, NULL, OPTION_SOFT_FLOAT},
11359   {"mhard-float", no_argument, NULL, OPTION_HARD_FLOAT},
11360   {"msingle-float", no_argument, NULL, OPTION_SINGLE_FLOAT},
11361   {"mdouble-float", no_argument, NULL, OPTION_DOUBLE_FLOAT},
11362
11363   /* Strictly speaking this next option is ELF specific,
11364      but we allow it for other ports as well in order to
11365      make testing easier.  */
11366   {"32",          no_argument, NULL, OPTION_32},
11367   
11368   /* ELF-specific options.  */
11369 #ifdef OBJ_ELF
11370   {"KPIC",        no_argument, NULL, OPTION_CALL_SHARED},
11371   {"call_shared", no_argument, NULL, OPTION_CALL_SHARED},
11372   {"call_nonpic", no_argument, NULL, OPTION_CALL_NONPIC},
11373   {"non_shared",  no_argument, NULL, OPTION_NON_SHARED},
11374   {"xgot",        no_argument, NULL, OPTION_XGOT},
11375   {"mabi", required_argument, NULL, OPTION_MABI},
11376   {"n32",         no_argument, NULL, OPTION_N32},
11377   {"64",          no_argument, NULL, OPTION_64},
11378   {"mdebug", no_argument, NULL, OPTION_MDEBUG},
11379   {"no-mdebug", no_argument, NULL, OPTION_NO_MDEBUG},
11380   {"mpdr", no_argument, NULL, OPTION_PDR},
11381   {"mno-pdr", no_argument, NULL, OPTION_NO_PDR},
11382   {"mvxworks-pic", no_argument, NULL, OPTION_MVXWORKS_PIC},
11383 #endif /* OBJ_ELF */
11384
11385   {NULL, no_argument, NULL, 0}
11386 };
11387 size_t md_longopts_size = sizeof (md_longopts);
11388
11389 /* Set STRING_PTR (either &mips_arch_string or &mips_tune_string) to
11390    NEW_VALUE.  Warn if another value was already specified.  Note:
11391    we have to defer parsing the -march and -mtune arguments in order
11392    to handle 'from-abi' correctly, since the ABI might be specified
11393    in a later argument.  */
11394
11395 static void
11396 mips_set_option_string (const char **string_ptr, const char *new_value)
11397 {
11398   if (*string_ptr != 0 && strcasecmp (*string_ptr, new_value) != 0)
11399     as_warn (_("A different %s was already specified, is now %s"),
11400              string_ptr == &mips_arch_string ? "-march" : "-mtune",
11401              new_value);
11402
11403   *string_ptr = new_value;
11404 }
11405
11406 int
11407 md_parse_option (int c, char *arg)
11408 {
11409   switch (c)
11410     {
11411     case OPTION_CONSTRUCT_FLOATS:
11412       mips_disable_float_construction = 0;
11413       break;
11414
11415     case OPTION_NO_CONSTRUCT_FLOATS:
11416       mips_disable_float_construction = 1;
11417       break;
11418
11419     case OPTION_TRAP:
11420       mips_trap = 1;
11421       break;
11422
11423     case OPTION_BREAK:
11424       mips_trap = 0;
11425       break;
11426
11427     case OPTION_EB:
11428       target_big_endian = 1;
11429       break;
11430
11431     case OPTION_EL:
11432       target_big_endian = 0;
11433       break;
11434
11435     case 'O':
11436       if (arg == NULL)
11437         mips_optimize = 1;
11438       else if (arg[0] == '0')
11439         mips_optimize = 0;
11440       else if (arg[0] == '1')
11441         mips_optimize = 1;
11442       else
11443         mips_optimize = 2;
11444       break;
11445
11446     case 'g':
11447       if (arg == NULL)
11448         mips_debug = 2;
11449       else
11450         mips_debug = atoi (arg);
11451       break;
11452
11453     case OPTION_MIPS1:
11454       file_mips_isa = ISA_MIPS1;
11455       break;
11456
11457     case OPTION_MIPS2:
11458       file_mips_isa = ISA_MIPS2;
11459       break;
11460
11461     case OPTION_MIPS3:
11462       file_mips_isa = ISA_MIPS3;
11463       break;
11464
11465     case OPTION_MIPS4:
11466       file_mips_isa = ISA_MIPS4;
11467       break;
11468
11469     case OPTION_MIPS5:
11470       file_mips_isa = ISA_MIPS5;
11471       break;
11472
11473     case OPTION_MIPS32:
11474       file_mips_isa = ISA_MIPS32;
11475       break;
11476
11477     case OPTION_MIPS32R2:
11478       file_mips_isa = ISA_MIPS32R2;
11479       break;
11480
11481     case OPTION_MIPS64R2:
11482       file_mips_isa = ISA_MIPS64R2;
11483       break;
11484
11485     case OPTION_MIPS64:
11486       file_mips_isa = ISA_MIPS64;
11487       break;
11488
11489     case OPTION_MTUNE:
11490       mips_set_option_string (&mips_tune_string, arg);
11491       break;
11492
11493     case OPTION_MARCH:
11494       mips_set_option_string (&mips_arch_string, arg);
11495       break;
11496
11497     case OPTION_M4650:
11498       mips_set_option_string (&mips_arch_string, "4650");
11499       mips_set_option_string (&mips_tune_string, "4650");
11500       break;
11501
11502     case OPTION_NO_M4650:
11503       break;
11504
11505     case OPTION_M4010:
11506       mips_set_option_string (&mips_arch_string, "4010");
11507       mips_set_option_string (&mips_tune_string, "4010");
11508       break;
11509
11510     case OPTION_NO_M4010:
11511       break;
11512
11513     case OPTION_M4100:
11514       mips_set_option_string (&mips_arch_string, "4100");
11515       mips_set_option_string (&mips_tune_string, "4100");
11516       break;
11517
11518     case OPTION_NO_M4100:
11519       break;
11520
11521     case OPTION_M3900:
11522       mips_set_option_string (&mips_arch_string, "3900");
11523       mips_set_option_string (&mips_tune_string, "3900");
11524       break;
11525
11526     case OPTION_NO_M3900:
11527       break;
11528
11529     case OPTION_MDMX:
11530       mips_opts.ase_mdmx = 1;
11531       break;
11532
11533     case OPTION_NO_MDMX:
11534       mips_opts.ase_mdmx = 0;
11535       break;
11536
11537     case OPTION_DSP:
11538       mips_opts.ase_dsp = 1;
11539       mips_opts.ase_dspr2 = 0;
11540       break;
11541
11542     case OPTION_NO_DSP:
11543       mips_opts.ase_dsp = 0;
11544       mips_opts.ase_dspr2 = 0;
11545       break;
11546
11547     case OPTION_DSPR2:
11548       mips_opts.ase_dspr2 = 1;
11549       mips_opts.ase_dsp = 1;
11550       break;
11551
11552     case OPTION_NO_DSPR2:
11553       mips_opts.ase_dspr2 = 0;
11554       mips_opts.ase_dsp = 0;
11555       break;
11556
11557     case OPTION_MT:
11558       mips_opts.ase_mt = 1;
11559       break;
11560
11561     case OPTION_NO_MT:
11562       mips_opts.ase_mt = 0;
11563       break;
11564
11565     case OPTION_MIPS16:
11566       mips_opts.mips16 = 1;
11567       mips_no_prev_insn ();
11568       break;
11569
11570     case OPTION_NO_MIPS16:
11571       mips_opts.mips16 = 0;
11572       mips_no_prev_insn ();
11573       break;
11574
11575     case OPTION_MIPS3D:
11576       mips_opts.ase_mips3d = 1;
11577       break;
11578
11579     case OPTION_NO_MIPS3D:
11580       mips_opts.ase_mips3d = 0;
11581       break;
11582
11583     case OPTION_SMARTMIPS:
11584       mips_opts.ase_smartmips = 1;
11585       break;
11586
11587     case OPTION_NO_SMARTMIPS:
11588       mips_opts.ase_smartmips = 0;
11589       break;
11590
11591     case OPTION_FIX_24K:
11592       mips_fix_24k = 1;
11593       break;
11594
11595     case OPTION_NO_FIX_24K:
11596       mips_fix_24k = 0;
11597       break;
11598
11599     case OPTION_FIX_LOONGSON2F_JUMP:
11600       mips_fix_loongson2f_jump = TRUE;
11601       break;
11602
11603     case OPTION_NO_FIX_LOONGSON2F_JUMP:
11604       mips_fix_loongson2f_jump = FALSE;
11605       break;
11606
11607     case OPTION_FIX_LOONGSON2F_NOP:
11608       mips_fix_loongson2f_nop = TRUE;
11609       break;
11610
11611     case OPTION_NO_FIX_LOONGSON2F_NOP:
11612       mips_fix_loongson2f_nop = FALSE;
11613       break;
11614
11615     case OPTION_FIX_VR4120:
11616       mips_fix_vr4120 = 1;
11617       break;
11618
11619     case OPTION_NO_FIX_VR4120:
11620       mips_fix_vr4120 = 0;
11621       break;
11622
11623     case OPTION_FIX_VR4130:
11624       mips_fix_vr4130 = 1;
11625       break;
11626
11627     case OPTION_NO_FIX_VR4130:
11628       mips_fix_vr4130 = 0;
11629       break;
11630
11631     case OPTION_FIX_CN63XXP1:
11632       mips_fix_cn63xxp1 = TRUE;
11633       break;
11634
11635     case OPTION_NO_FIX_CN63XXP1:
11636       mips_fix_cn63xxp1 = FALSE;
11637       break;
11638
11639     case OPTION_RELAX_BRANCH:
11640       mips_relax_branch = 1;
11641       break;
11642
11643     case OPTION_NO_RELAX_BRANCH:
11644       mips_relax_branch = 0;
11645       break;
11646
11647     case OPTION_MSHARED:
11648       mips_in_shared = TRUE;
11649       break;
11650
11651     case OPTION_MNO_SHARED:
11652       mips_in_shared = FALSE;
11653       break;
11654
11655     case OPTION_MSYM32:
11656       mips_opts.sym32 = TRUE;
11657       break;
11658
11659     case OPTION_MNO_SYM32:
11660       mips_opts.sym32 = FALSE;
11661       break;
11662
11663 #ifdef OBJ_ELF
11664       /* When generating ELF code, we permit -KPIC and -call_shared to
11665          select SVR4_PIC, and -non_shared to select no PIC.  This is
11666          intended to be compatible with Irix 5.  */
11667     case OPTION_CALL_SHARED:
11668       if (!IS_ELF)
11669         {
11670           as_bad (_("-call_shared is supported only for ELF format"));
11671           return 0;
11672         }
11673       mips_pic = SVR4_PIC;
11674       mips_abicalls = TRUE;
11675       break;
11676
11677     case OPTION_CALL_NONPIC:
11678       if (!IS_ELF)
11679         {
11680           as_bad (_("-call_nonpic is supported only for ELF format"));
11681           return 0;
11682         }
11683       mips_pic = NO_PIC;
11684       mips_abicalls = TRUE;
11685       break;
11686
11687     case OPTION_NON_SHARED:
11688       if (!IS_ELF)
11689         {
11690           as_bad (_("-non_shared is supported only for ELF format"));
11691           return 0;
11692         }
11693       mips_pic = NO_PIC;
11694       mips_abicalls = FALSE;
11695       break;
11696
11697       /* The -xgot option tells the assembler to use 32 bit offsets
11698          when accessing the got in SVR4_PIC mode.  It is for Irix
11699          compatibility.  */
11700     case OPTION_XGOT:
11701       mips_big_got = 1;
11702       break;
11703 #endif /* OBJ_ELF */
11704
11705     case 'G':
11706       g_switch_value = atoi (arg);
11707       g_switch_seen = 1;
11708       break;
11709
11710       /* The -32, -n32 and -64 options are shortcuts for -mabi=32, -mabi=n32
11711          and -mabi=64.  */
11712     case OPTION_32:
11713       if (IS_ELF)
11714         mips_abi = O32_ABI;
11715       /* We silently ignore -32 for non-ELF targets.  This greatly
11716          simplifies the construction of the MIPS GAS test cases.  */
11717       break;
11718
11719 #ifdef OBJ_ELF
11720     case OPTION_N32:
11721       if (!IS_ELF)
11722         {
11723           as_bad (_("-n32 is supported for ELF format only"));
11724           return 0;
11725         }
11726       mips_abi = N32_ABI;
11727       break;
11728
11729     case OPTION_64:
11730       if (!IS_ELF)
11731         {
11732           as_bad (_("-64 is supported for ELF format only"));
11733           return 0;
11734         }
11735       mips_abi = N64_ABI;
11736       if (!support_64bit_objects())
11737         as_fatal (_("No compiled in support for 64 bit object file format"));
11738       break;
11739 #endif /* OBJ_ELF */
11740
11741     case OPTION_GP32:
11742       file_mips_gp32 = 1;
11743       break;
11744
11745     case OPTION_GP64:
11746       file_mips_gp32 = 0;
11747       break;
11748
11749     case OPTION_FP32:
11750       file_mips_fp32 = 1;
11751       break;
11752
11753     case OPTION_FP64:
11754       file_mips_fp32 = 0;
11755       break;
11756
11757     case OPTION_SINGLE_FLOAT:
11758       file_mips_single_float = 1;
11759       break;
11760
11761     case OPTION_DOUBLE_FLOAT:
11762       file_mips_single_float = 0;
11763       break;
11764
11765     case OPTION_SOFT_FLOAT:
11766       file_mips_soft_float = 1;
11767       break;
11768
11769     case OPTION_HARD_FLOAT:
11770       file_mips_soft_float = 0;
11771       break;
11772
11773 #ifdef OBJ_ELF
11774     case OPTION_MABI:
11775       if (!IS_ELF)
11776         {
11777           as_bad (_("-mabi is supported for ELF format only"));
11778           return 0;
11779         }
11780       if (strcmp (arg, "32") == 0)
11781         mips_abi = O32_ABI;
11782       else if (strcmp (arg, "o64") == 0)
11783         mips_abi = O64_ABI;
11784       else if (strcmp (arg, "n32") == 0)
11785         mips_abi = N32_ABI;
11786       else if (strcmp (arg, "64") == 0)
11787         {
11788           mips_abi = N64_ABI;
11789           if (! support_64bit_objects())
11790             as_fatal (_("No compiled in support for 64 bit object file "
11791                         "format"));
11792         }
11793       else if (strcmp (arg, "eabi") == 0)
11794         mips_abi = EABI_ABI;
11795       else
11796         {
11797           as_fatal (_("invalid abi -mabi=%s"), arg);
11798           return 0;
11799         }
11800       break;
11801 #endif /* OBJ_ELF */
11802
11803     case OPTION_M7000_HILO_FIX:
11804       mips_7000_hilo_fix = TRUE;
11805       break;
11806
11807     case OPTION_MNO_7000_HILO_FIX:
11808       mips_7000_hilo_fix = FALSE;
11809       break;
11810
11811 #ifdef OBJ_ELF
11812     case OPTION_MDEBUG:
11813       mips_flag_mdebug = TRUE;
11814       break;
11815
11816     case OPTION_NO_MDEBUG:
11817       mips_flag_mdebug = FALSE;
11818       break;
11819
11820     case OPTION_PDR:
11821       mips_flag_pdr = TRUE;
11822       break;
11823
11824     case OPTION_NO_PDR:
11825       mips_flag_pdr = FALSE;
11826       break;
11827
11828     case OPTION_MVXWORKS_PIC:
11829       mips_pic = VXWORKS_PIC;
11830       break;
11831 #endif /* OBJ_ELF */
11832
11833     default:
11834       return 0;
11835     }
11836
11837     mips_fix_loongson2f = mips_fix_loongson2f_nop || mips_fix_loongson2f_jump;
11838
11839   return 1;
11840 }
11841 \f
11842 /* Set up globals to generate code for the ISA or processor
11843    described by INFO.  */
11844
11845 static void
11846 mips_set_architecture (const struct mips_cpu_info *info)
11847 {
11848   if (info != 0)
11849     {
11850       file_mips_arch = info->cpu;
11851       mips_opts.arch = info->cpu;
11852       mips_opts.isa = info->isa;
11853     }
11854 }
11855
11856
11857 /* Likewise for tuning.  */
11858
11859 static void
11860 mips_set_tune (const struct mips_cpu_info *info)
11861 {
11862   if (info != 0)
11863     mips_tune = info->cpu;
11864 }
11865
11866
11867 void
11868 mips_after_parse_args (void)
11869 {
11870   const struct mips_cpu_info *arch_info = 0;
11871   const struct mips_cpu_info *tune_info = 0;
11872
11873   /* GP relative stuff not working for PE */
11874   if (strncmp (TARGET_OS, "pe", 2) == 0)
11875     {
11876       if (g_switch_seen && g_switch_value != 0)
11877         as_bad (_("-G not supported in this configuration."));
11878       g_switch_value = 0;
11879     }
11880
11881   if (mips_abi == NO_ABI)
11882     mips_abi = MIPS_DEFAULT_ABI;
11883
11884   /* The following code determines the architecture and register size.
11885      Similar code was added to GCC 3.3 (see override_options() in
11886      config/mips/mips.c).  The GAS and GCC code should be kept in sync
11887      as much as possible.  */
11888
11889   if (mips_arch_string != 0)
11890     arch_info = mips_parse_cpu ("-march", mips_arch_string);
11891
11892   if (file_mips_isa != ISA_UNKNOWN)
11893     {
11894       /* Handle -mipsN.  At this point, file_mips_isa contains the
11895          ISA level specified by -mipsN, while arch_info->isa contains
11896          the -march selection (if any).  */
11897       if (arch_info != 0)
11898         {
11899           /* -march takes precedence over -mipsN, since it is more descriptive.
11900              There's no harm in specifying both as long as the ISA levels
11901              are the same.  */
11902           if (file_mips_isa != arch_info->isa)
11903             as_bad (_("-%s conflicts with the other architecture options, which imply -%s"),
11904                     mips_cpu_info_from_isa (file_mips_isa)->name,
11905                     mips_cpu_info_from_isa (arch_info->isa)->name);
11906         }
11907       else
11908         arch_info = mips_cpu_info_from_isa (file_mips_isa);
11909     }
11910
11911   if (arch_info == 0)
11912     arch_info = mips_parse_cpu ("default CPU", MIPS_CPU_STRING_DEFAULT);
11913
11914   if (ABI_NEEDS_64BIT_REGS (mips_abi) && !ISA_HAS_64BIT_REGS (arch_info->isa))
11915     as_bad (_("-march=%s is not compatible with the selected ABI"),
11916             arch_info->name);
11917
11918   mips_set_architecture (arch_info);
11919
11920   /* Optimize for file_mips_arch, unless -mtune selects a different processor.  */
11921   if (mips_tune_string != 0)
11922     tune_info = mips_parse_cpu ("-mtune", mips_tune_string);
11923
11924   if (tune_info == 0)
11925     mips_set_tune (arch_info);
11926   else
11927     mips_set_tune (tune_info);
11928
11929   if (file_mips_gp32 >= 0)
11930     {
11931       /* The user specified the size of the integer registers.  Make sure
11932          it agrees with the ABI and ISA.  */
11933       if (file_mips_gp32 == 0 && !ISA_HAS_64BIT_REGS (mips_opts.isa))
11934         as_bad (_("-mgp64 used with a 32-bit processor"));
11935       else if (file_mips_gp32 == 1 && ABI_NEEDS_64BIT_REGS (mips_abi))
11936         as_bad (_("-mgp32 used with a 64-bit ABI"));
11937       else if (file_mips_gp32 == 0 && ABI_NEEDS_32BIT_REGS (mips_abi))
11938         as_bad (_("-mgp64 used with a 32-bit ABI"));
11939     }
11940   else
11941     {
11942       /* Infer the integer register size from the ABI and processor.
11943          Restrict ourselves to 32-bit registers if that's all the
11944          processor has, or if the ABI cannot handle 64-bit registers.  */
11945       file_mips_gp32 = (ABI_NEEDS_32BIT_REGS (mips_abi)
11946                         || !ISA_HAS_64BIT_REGS (mips_opts.isa));
11947     }
11948
11949   switch (file_mips_fp32)
11950     {
11951     default:
11952     case -1:
11953       /* No user specified float register size.
11954          ??? GAS treats single-float processors as though they had 64-bit
11955          float registers (although it complains when double-precision
11956          instructions are used).  As things stand, saying they have 32-bit
11957          registers would lead to spurious "register must be even" messages.
11958          So here we assume float registers are never smaller than the
11959          integer ones.  */
11960       if (file_mips_gp32 == 0)
11961         /* 64-bit integer registers implies 64-bit float registers.  */
11962         file_mips_fp32 = 0;
11963       else if ((mips_opts.ase_mips3d > 0 || mips_opts.ase_mdmx > 0)
11964                && ISA_HAS_64BIT_FPRS (mips_opts.isa))
11965         /* -mips3d and -mdmx imply 64-bit float registers, if possible.  */
11966         file_mips_fp32 = 0;
11967       else
11968         /* 32-bit float registers.  */
11969         file_mips_fp32 = 1;
11970       break;
11971
11972     /* The user specified the size of the float registers.  Check if it
11973        agrees with the ABI and ISA.  */
11974     case 0:
11975       if (!ISA_HAS_64BIT_FPRS (mips_opts.isa))
11976         as_bad (_("-mfp64 used with a 32-bit fpu"));
11977       else if (ABI_NEEDS_32BIT_REGS (mips_abi)
11978                && !ISA_HAS_MXHC1 (mips_opts.isa))
11979         as_warn (_("-mfp64 used with a 32-bit ABI"));
11980       break;
11981     case 1:
11982       if (ABI_NEEDS_64BIT_REGS (mips_abi))
11983         as_warn (_("-mfp32 used with a 64-bit ABI"));
11984       break;
11985     }
11986
11987   /* End of GCC-shared inference code.  */
11988
11989   /* This flag is set when we have a 64-bit capable CPU but use only
11990      32-bit wide registers.  Note that EABI does not use it.  */
11991   if (ISA_HAS_64BIT_REGS (mips_opts.isa)
11992       && ((mips_abi == NO_ABI && file_mips_gp32 == 1)
11993           || mips_abi == O32_ABI))
11994     mips_32bitmode = 1;
11995
11996   if (mips_opts.isa == ISA_MIPS1 && mips_trap)
11997     as_bad (_("trap exception not supported at ISA 1"));
11998
11999   /* If the selected architecture includes support for ASEs, enable
12000      generation of code for them.  */
12001   if (mips_opts.mips16 == -1)
12002     mips_opts.mips16 = (CPU_HAS_MIPS16 (file_mips_arch)) ? 1 : 0;
12003   if (mips_opts.ase_mips3d == -1)
12004     mips_opts.ase_mips3d = ((arch_info->flags & MIPS_CPU_ASE_MIPS3D)
12005                             && file_mips_fp32 == 0) ? 1 : 0;
12006   if (mips_opts.ase_mips3d && file_mips_fp32 == 1)
12007     as_bad (_("-mfp32 used with -mips3d"));
12008
12009   if (mips_opts.ase_mdmx == -1)
12010     mips_opts.ase_mdmx = ((arch_info->flags & MIPS_CPU_ASE_MDMX)
12011                           && file_mips_fp32 == 0) ? 1 : 0;
12012   if (mips_opts.ase_mdmx && file_mips_fp32 == 1)
12013     as_bad (_("-mfp32 used with -mdmx"));
12014
12015   if (mips_opts.ase_smartmips == -1)
12016     mips_opts.ase_smartmips = (arch_info->flags & MIPS_CPU_ASE_SMARTMIPS) ? 1 : 0;
12017   if (mips_opts.ase_smartmips && !ISA_SUPPORTS_SMARTMIPS)
12018     as_warn (_("%s ISA does not support SmartMIPS"), 
12019              mips_cpu_info_from_isa (mips_opts.isa)->name);
12020
12021   if (mips_opts.ase_dsp == -1)
12022     mips_opts.ase_dsp = (arch_info->flags & MIPS_CPU_ASE_DSP) ? 1 : 0;
12023   if (mips_opts.ase_dsp && !ISA_SUPPORTS_DSP_ASE)
12024     as_warn (_("%s ISA does not support DSP ASE"), 
12025              mips_cpu_info_from_isa (mips_opts.isa)->name);
12026
12027   if (mips_opts.ase_dspr2 == -1)
12028     {
12029       mips_opts.ase_dspr2 = (arch_info->flags & MIPS_CPU_ASE_DSPR2) ? 1 : 0;
12030       mips_opts.ase_dsp = (arch_info->flags & MIPS_CPU_ASE_DSP) ? 1 : 0;
12031     }
12032   if (mips_opts.ase_dspr2 && !ISA_SUPPORTS_DSPR2_ASE)
12033     as_warn (_("%s ISA does not support DSP R2 ASE"),
12034              mips_cpu_info_from_isa (mips_opts.isa)->name);
12035
12036   if (mips_opts.ase_mt == -1)
12037     mips_opts.ase_mt = (arch_info->flags & MIPS_CPU_ASE_MT) ? 1 : 0;
12038   if (mips_opts.ase_mt && !ISA_SUPPORTS_MT_ASE)
12039     as_warn (_("%s ISA does not support MT ASE"),
12040              mips_cpu_info_from_isa (mips_opts.isa)->name);
12041
12042   file_mips_isa = mips_opts.isa;
12043   file_ase_mips16 = mips_opts.mips16;
12044   file_ase_mips3d = mips_opts.ase_mips3d;
12045   file_ase_mdmx = mips_opts.ase_mdmx;
12046   file_ase_smartmips = mips_opts.ase_smartmips;
12047   file_ase_dsp = mips_opts.ase_dsp;
12048   file_ase_dspr2 = mips_opts.ase_dspr2;
12049   file_ase_mt = mips_opts.ase_mt;
12050   mips_opts.gp32 = file_mips_gp32;
12051   mips_opts.fp32 = file_mips_fp32;
12052   mips_opts.soft_float = file_mips_soft_float;
12053   mips_opts.single_float = file_mips_single_float;
12054
12055   if (mips_flag_mdebug < 0)
12056     {
12057 #ifdef OBJ_MAYBE_ECOFF
12058       if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour)
12059         mips_flag_mdebug = 1;
12060       else
12061 #endif /* OBJ_MAYBE_ECOFF */
12062         mips_flag_mdebug = 0;
12063     }
12064 }
12065 \f
12066 void
12067 mips_init_after_args (void)
12068 {
12069   /* initialize opcodes */
12070   bfd_mips_num_opcodes = bfd_mips_num_builtin_opcodes;
12071   mips_opcodes = (struct mips_opcode *) mips_builtin_opcodes;
12072 }
12073
12074 long
12075 md_pcrel_from (fixS *fixP)
12076 {
12077   valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
12078   switch (fixP->fx_r_type)
12079     {
12080     case BFD_RELOC_16_PCREL_S2:
12081     case BFD_RELOC_MIPS_JMP:
12082       /* Return the address of the delay slot.  */
12083       return addr + 4;
12084     default:
12085       /* We have no relocation type for PC relative MIPS16 instructions.  */
12086       if (fixP->fx_addsy && S_GET_SEGMENT (fixP->fx_addsy) != now_seg)
12087         as_bad_where (fixP->fx_file, fixP->fx_line,
12088                       _("PC relative MIPS16 instruction references a different section"));
12089       return addr;
12090     }
12091 }
12092
12093 /* This is called before the symbol table is processed.  In order to
12094    work with gcc when using mips-tfile, we must keep all local labels.
12095    However, in other cases, we want to discard them.  If we were
12096    called with -g, but we didn't see any debugging information, it may
12097    mean that gcc is smuggling debugging information through to
12098    mips-tfile, in which case we must generate all local labels.  */
12099
12100 void
12101 mips_frob_file_before_adjust (void)
12102 {
12103 #ifndef NO_ECOFF_DEBUGGING
12104   if (ECOFF_DEBUGGING
12105       && mips_debug != 0
12106       && ! ecoff_debugging_seen)
12107     flag_keep_locals = 1;
12108 #endif
12109 }
12110
12111 /* Sort any unmatched HI16 and GOT16 relocs so that they immediately precede
12112    the corresponding LO16 reloc.  This is called before md_apply_fix and
12113    tc_gen_reloc.  Unmatched relocs can only be generated by use of explicit
12114    relocation operators.
12115
12116    For our purposes, a %lo() expression matches a %got() or %hi()
12117    expression if:
12118
12119       (a) it refers to the same symbol; and
12120       (b) the offset applied in the %lo() expression is no lower than
12121           the offset applied in the %got() or %hi().
12122
12123    (b) allows us to cope with code like:
12124
12125         lui     $4,%hi(foo)
12126         lh      $4,%lo(foo+2)($4)
12127
12128    ...which is legal on RELA targets, and has a well-defined behaviour
12129    if the user knows that adding 2 to "foo" will not induce a carry to
12130    the high 16 bits.
12131
12132    When several %lo()s match a particular %got() or %hi(), we use the
12133    following rules to distinguish them:
12134
12135      (1) %lo()s with smaller offsets are a better match than %lo()s with
12136          higher offsets.
12137
12138      (2) %lo()s with no matching %got() or %hi() are better than those
12139          that already have a matching %got() or %hi().
12140
12141      (3) later %lo()s are better than earlier %lo()s.
12142
12143    These rules are applied in order.
12144
12145    (1) means, among other things, that %lo()s with identical offsets are
12146    chosen if they exist.
12147
12148    (2) means that we won't associate several high-part relocations with
12149    the same low-part relocation unless there's no alternative.  Having
12150    several high parts for the same low part is a GNU extension; this rule
12151    allows careful users to avoid it.
12152
12153    (3) is purely cosmetic.  mips_hi_fixup_list is is in reverse order,
12154    with the last high-part relocation being at the front of the list.
12155    It therefore makes sense to choose the last matching low-part
12156    relocation, all other things being equal.  It's also easier
12157    to code that way.  */
12158
12159 void
12160 mips_frob_file (void)
12161 {
12162   struct mips_hi_fixup *l;
12163   bfd_reloc_code_real_type looking_for_rtype = BFD_RELOC_UNUSED;
12164
12165   for (l = mips_hi_fixup_list; l != NULL; l = l->next)
12166     {
12167       segment_info_type *seginfo;
12168       bfd_boolean matched_lo_p;
12169       fixS **hi_pos, **lo_pos, **pos;
12170
12171       gas_assert (reloc_needs_lo_p (l->fixp->fx_r_type));
12172
12173       /* If a GOT16 relocation turns out to be against a global symbol,
12174          there isn't supposed to be a matching LO.  */
12175       if (got16_reloc_p (l->fixp->fx_r_type)
12176           && !pic_need_relax (l->fixp->fx_addsy, l->seg))
12177         continue;
12178
12179       /* Check quickly whether the next fixup happens to be a matching %lo.  */
12180       if (fixup_has_matching_lo_p (l->fixp))
12181         continue;
12182
12183       seginfo = seg_info (l->seg);
12184
12185       /* Set HI_POS to the position of this relocation in the chain.
12186          Set LO_POS to the position of the chosen low-part relocation.
12187          MATCHED_LO_P is true on entry to the loop if *POS is a low-part
12188          relocation that matches an immediately-preceding high-part
12189          relocation.  */
12190       hi_pos = NULL;
12191       lo_pos = NULL;
12192       matched_lo_p = FALSE;
12193       looking_for_rtype = matching_lo_reloc (l->fixp->fx_r_type);
12194
12195       for (pos = &seginfo->fix_root; *pos != NULL; pos = &(*pos)->fx_next)
12196         {
12197           if (*pos == l->fixp)
12198             hi_pos = pos;
12199
12200           if ((*pos)->fx_r_type == looking_for_rtype
12201               && symbol_same_p ((*pos)->fx_addsy, l->fixp->fx_addsy)
12202               && (*pos)->fx_offset >= l->fixp->fx_offset
12203               && (lo_pos == NULL
12204                   || (*pos)->fx_offset < (*lo_pos)->fx_offset
12205                   || (!matched_lo_p
12206                       && (*pos)->fx_offset == (*lo_pos)->fx_offset)))
12207             lo_pos = pos;
12208
12209           matched_lo_p = (reloc_needs_lo_p ((*pos)->fx_r_type)
12210                           && fixup_has_matching_lo_p (*pos));
12211         }
12212
12213       /* If we found a match, remove the high-part relocation from its
12214          current position and insert it before the low-part relocation.
12215          Make the offsets match so that fixup_has_matching_lo_p()
12216          will return true.
12217
12218          We don't warn about unmatched high-part relocations since some
12219          versions of gcc have been known to emit dead "lui ...%hi(...)"
12220          instructions.  */
12221       if (lo_pos != NULL)
12222         {
12223           l->fixp->fx_offset = (*lo_pos)->fx_offset;
12224           if (l->fixp->fx_next != *lo_pos)
12225             {
12226               *hi_pos = l->fixp->fx_next;
12227               l->fixp->fx_next = *lo_pos;
12228               *lo_pos = l->fixp;
12229             }
12230         }
12231     }
12232 }
12233
12234 /* We may have combined relocations without symbols in the N32/N64 ABI.
12235    We have to prevent gas from dropping them.  */
12236
12237 int
12238 mips_force_relocation (fixS *fixp)
12239 {
12240   if (generic_force_reloc (fixp))
12241     return 1;
12242
12243   if (HAVE_NEWABI
12244       && S_GET_SEGMENT (fixp->fx_addsy) == bfd_abs_section_ptr
12245       && (fixp->fx_r_type == BFD_RELOC_MIPS_SUB
12246           || hi16_reloc_p (fixp->fx_r_type)
12247           || lo16_reloc_p (fixp->fx_r_type)))
12248     return 1;
12249
12250   return 0;
12251 }
12252
12253 /* Apply a fixup to the object file.  */
12254
12255 void
12256 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
12257 {
12258   bfd_byte *buf;
12259   long insn;
12260   reloc_howto_type *howto;
12261
12262   /* We ignore generic BFD relocations we don't know about.  */
12263   howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
12264   if (! howto)
12265     return;
12266
12267   gas_assert (fixP->fx_size == 4
12268           || fixP->fx_r_type == BFD_RELOC_16
12269           || fixP->fx_r_type == BFD_RELOC_64
12270           || fixP->fx_r_type == BFD_RELOC_CTOR
12271           || fixP->fx_r_type == BFD_RELOC_MIPS_SUB
12272           || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
12273           || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
12274           || fixP->fx_r_type == BFD_RELOC_MIPS_TLS_DTPREL64);
12275
12276   buf = (bfd_byte *) (fixP->fx_frag->fr_literal + fixP->fx_where);
12277
12278   gas_assert (!fixP->fx_pcrel || fixP->fx_r_type == BFD_RELOC_16_PCREL_S2);
12279
12280   /* Don't treat parts of a composite relocation as done.  There are two
12281      reasons for this:
12282
12283      (1) The second and third parts will be against 0 (RSS_UNDEF) but
12284          should nevertheless be emitted if the first part is.
12285
12286      (2) In normal usage, composite relocations are never assembly-time
12287          constants.  The easiest way of dealing with the pathological
12288          exceptions is to generate a relocation against STN_UNDEF and
12289          leave everything up to the linker.  */
12290   if (fixP->fx_addsy == NULL && !fixP->fx_pcrel && fixP->fx_tcbit == 0)
12291     fixP->fx_done = 1;
12292
12293   switch (fixP->fx_r_type)
12294     {
12295     case BFD_RELOC_MIPS_TLS_GD:
12296     case BFD_RELOC_MIPS_TLS_LDM:
12297     case BFD_RELOC_MIPS_TLS_DTPREL32:
12298     case BFD_RELOC_MIPS_TLS_DTPREL64:
12299     case BFD_RELOC_MIPS_TLS_DTPREL_HI16:
12300     case BFD_RELOC_MIPS_TLS_DTPREL_LO16:
12301     case BFD_RELOC_MIPS_TLS_GOTTPREL:
12302     case BFD_RELOC_MIPS_TLS_TPREL_HI16:
12303     case BFD_RELOC_MIPS_TLS_TPREL_LO16:
12304       S_SET_THREAD_LOCAL (fixP->fx_addsy);
12305       /* fall through */
12306
12307     case BFD_RELOC_MIPS_JMP:
12308     case BFD_RELOC_MIPS_SHIFT5:
12309     case BFD_RELOC_MIPS_SHIFT6:
12310     case BFD_RELOC_MIPS_GOT_DISP:
12311     case BFD_RELOC_MIPS_GOT_PAGE:
12312     case BFD_RELOC_MIPS_GOT_OFST:
12313     case BFD_RELOC_MIPS_SUB:
12314     case BFD_RELOC_MIPS_INSERT_A:
12315     case BFD_RELOC_MIPS_INSERT_B:
12316     case BFD_RELOC_MIPS_DELETE:
12317     case BFD_RELOC_MIPS_HIGHEST:
12318     case BFD_RELOC_MIPS_HIGHER:
12319     case BFD_RELOC_MIPS_SCN_DISP:
12320     case BFD_RELOC_MIPS_REL16:
12321     case BFD_RELOC_MIPS_RELGOT:
12322     case BFD_RELOC_MIPS_JALR:
12323     case BFD_RELOC_HI16:
12324     case BFD_RELOC_HI16_S:
12325     case BFD_RELOC_GPREL16:
12326     case BFD_RELOC_MIPS_LITERAL:
12327     case BFD_RELOC_MIPS_CALL16:
12328     case BFD_RELOC_MIPS_GOT16:
12329     case BFD_RELOC_GPREL32:
12330     case BFD_RELOC_MIPS_GOT_HI16:
12331     case BFD_RELOC_MIPS_GOT_LO16:
12332     case BFD_RELOC_MIPS_CALL_HI16:
12333     case BFD_RELOC_MIPS_CALL_LO16:
12334     case BFD_RELOC_MIPS16_GPREL:
12335     case BFD_RELOC_MIPS16_GOT16:
12336     case BFD_RELOC_MIPS16_CALL16:
12337     case BFD_RELOC_MIPS16_HI16:
12338     case BFD_RELOC_MIPS16_HI16_S:
12339     case BFD_RELOC_MIPS16_JMP:
12340       /* Nothing needed to do.  The value comes from the reloc entry.  */
12341       break;
12342
12343     case BFD_RELOC_64:
12344       /* This is handled like BFD_RELOC_32, but we output a sign
12345          extended value if we are only 32 bits.  */
12346       if (fixP->fx_done)
12347         {
12348           if (8 <= sizeof (valueT))
12349             md_number_to_chars ((char *) buf, *valP, 8);
12350           else
12351             {
12352               valueT hiv;
12353
12354               if ((*valP & 0x80000000) != 0)
12355                 hiv = 0xffffffff;
12356               else
12357                 hiv = 0;
12358               md_number_to_chars ((char *)(buf + (target_big_endian ? 4 : 0)),
12359                                   *valP, 4);
12360               md_number_to_chars ((char *)(buf + (target_big_endian ? 0 : 4)),
12361                                   hiv, 4);
12362             }
12363         }
12364       break;
12365
12366     case BFD_RELOC_RVA:
12367     case BFD_RELOC_32:
12368     case BFD_RELOC_16:
12369       /* If we are deleting this reloc entry, we must fill in the
12370          value now.  This can happen if we have a .word which is not
12371          resolved when it appears but is later defined.  */
12372       if (fixP->fx_done)
12373         md_number_to_chars ((char *) buf, *valP, fixP->fx_size);
12374       break;
12375
12376     case BFD_RELOC_LO16:
12377     case BFD_RELOC_MIPS16_LO16:
12378       /* FIXME: Now that embedded-PIC is gone, some of this code/comment
12379          may be safe to remove, but if so it's not obvious.  */
12380       /* When handling an embedded PIC switch statement, we can wind
12381          up deleting a LO16 reloc.  See the 'o' case in mips_ip.  */
12382       if (fixP->fx_done)
12383         {
12384           if (*valP + 0x8000 > 0xffff)
12385             as_bad_where (fixP->fx_file, fixP->fx_line,
12386                           _("relocation overflow"));
12387           if (target_big_endian)
12388             buf += 2;
12389           md_number_to_chars ((char *) buf, *valP, 2);
12390         }
12391       break;
12392
12393     case BFD_RELOC_16_PCREL_S2:
12394       if ((*valP & 0x3) != 0)
12395         as_bad_where (fixP->fx_file, fixP->fx_line,
12396                       _("Branch to misaligned address (%lx)"), (long) *valP);
12397
12398       /* We need to save the bits in the instruction since fixup_segment()
12399          might be deleting the relocation entry (i.e., a branch within
12400          the current segment).  */
12401       if (! fixP->fx_done)
12402         break;
12403
12404       /* Update old instruction data.  */
12405       if (target_big_endian)
12406         insn = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
12407       else
12408         insn = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
12409
12410       if (*valP + 0x20000 <= 0x3ffff)
12411         {
12412           insn |= (*valP >> 2) & 0xffff;
12413           md_number_to_chars ((char *) buf, insn, 4);
12414         }
12415       else if (mips_pic == NO_PIC
12416                && fixP->fx_done
12417                && fixP->fx_frag->fr_address >= text_section->vma
12418                && (fixP->fx_frag->fr_address
12419                    < text_section->vma + bfd_get_section_size (text_section))
12420                && ((insn & 0xffff0000) == 0x10000000     /* beq $0,$0 */
12421                    || (insn & 0xffff0000) == 0x04010000  /* bgez $0 */
12422                    || (insn & 0xffff0000) == 0x04110000)) /* bgezal $0 */
12423         {
12424           /* The branch offset is too large.  If this is an
12425              unconditional branch, and we are not generating PIC code,
12426              we can convert it to an absolute jump instruction.  */
12427           if ((insn & 0xffff0000) == 0x04110000)         /* bgezal $0 */
12428             insn = 0x0c000000;  /* jal */
12429           else
12430             insn = 0x08000000;  /* j */
12431           fixP->fx_r_type = BFD_RELOC_MIPS_JMP;
12432           fixP->fx_done = 0;
12433           fixP->fx_addsy = section_symbol (text_section);
12434           *valP += md_pcrel_from (fixP);
12435           md_number_to_chars ((char *) buf, insn, 4);
12436         }
12437       else
12438         {
12439           /* If we got here, we have branch-relaxation disabled,
12440              and there's nothing we can do to fix this instruction
12441              without turning it into a longer sequence.  */
12442           as_bad_where (fixP->fx_file, fixP->fx_line,
12443                         _("Branch out of range"));
12444         }
12445       break;
12446
12447     case BFD_RELOC_VTABLE_INHERIT:
12448       fixP->fx_done = 0;
12449       if (fixP->fx_addsy
12450           && !S_IS_DEFINED (fixP->fx_addsy)
12451           && !S_IS_WEAK (fixP->fx_addsy))
12452         S_SET_WEAK (fixP->fx_addsy);
12453       break;
12454
12455     case BFD_RELOC_VTABLE_ENTRY:
12456       fixP->fx_done = 0;
12457       break;
12458
12459     default:
12460       internalError ();
12461     }
12462
12463   /* Remember value for tc_gen_reloc.  */
12464   fixP->fx_addnumber = *valP;
12465 }
12466
12467 static symbolS *
12468 get_symbol (void)
12469 {
12470   int c;
12471   char *name;
12472   symbolS *p;
12473
12474   name = input_line_pointer;
12475   c = get_symbol_end ();
12476   p = (symbolS *) symbol_find_or_make (name);
12477   *input_line_pointer = c;
12478   return p;
12479 }
12480
12481 /* Align the current frag to a given power of two.  If a particular
12482    fill byte should be used, FILL points to an integer that contains
12483    that byte, otherwise FILL is null.
12484
12485    The MIPS assembler also automatically adjusts any preceding
12486    label.  */
12487
12488 static void
12489 mips_align (int to, int *fill, symbolS *label)
12490 {
12491   mips_emit_delays ();
12492   mips_record_mips16_mode ();
12493   if (fill == NULL && subseg_text_p (now_seg))
12494     frag_align_code (to, 0);
12495   else
12496     frag_align (to, fill ? *fill : 0, 0);
12497   record_alignment (now_seg, to);
12498   if (label != NULL)
12499     {
12500       gas_assert (S_GET_SEGMENT (label) == now_seg);
12501       symbol_set_frag (label, frag_now);
12502       S_SET_VALUE (label, (valueT) frag_now_fix ());
12503     }
12504 }
12505
12506 /* Align to a given power of two.  .align 0 turns off the automatic
12507    alignment used by the data creating pseudo-ops.  */
12508
12509 static void
12510 s_align (int x ATTRIBUTE_UNUSED)
12511 {
12512   int temp, fill_value, *fill_ptr;
12513   long max_alignment = 28;
12514
12515   /* o Note that the assembler pulls down any immediately preceding label
12516        to the aligned address.
12517      o It's not documented but auto alignment is reinstated by
12518        a .align pseudo instruction.
12519      o Note also that after auto alignment is turned off the mips assembler
12520        issues an error on attempt to assemble an improperly aligned data item.
12521        We don't.  */
12522
12523   temp = get_absolute_expression ();
12524   if (temp > max_alignment)
12525     as_bad (_("Alignment too large: %d. assumed."), temp = max_alignment);
12526   else if (temp < 0)
12527     {
12528       as_warn (_("Alignment negative: 0 assumed."));
12529       temp = 0;
12530     }
12531   if (*input_line_pointer == ',')
12532     {
12533       ++input_line_pointer;
12534       fill_value = get_absolute_expression ();
12535       fill_ptr = &fill_value;
12536     }
12537   else
12538     fill_ptr = 0;
12539   if (temp)
12540     {
12541       segment_info_type *si = seg_info (now_seg);
12542       struct insn_label_list *l = si->label_list;
12543       /* Auto alignment should be switched on by next section change.  */
12544       auto_align = 1;
12545       mips_align (temp, fill_ptr, l != NULL ? l->label : NULL);
12546     }
12547   else
12548     {
12549       auto_align = 0;
12550     }
12551
12552   demand_empty_rest_of_line ();
12553 }
12554
12555 static void
12556 s_change_sec (int sec)
12557 {
12558   segT seg;
12559
12560 #ifdef OBJ_ELF
12561   /* The ELF backend needs to know that we are changing sections, so
12562      that .previous works correctly.  We could do something like check
12563      for an obj_section_change_hook macro, but that might be confusing
12564      as it would not be appropriate to use it in the section changing
12565      functions in read.c, since obj-elf.c intercepts those.  FIXME:
12566      This should be cleaner, somehow.  */
12567   if (IS_ELF)
12568     obj_elf_section_change_hook ();
12569 #endif
12570
12571   mips_emit_delays ();
12572
12573   switch (sec)
12574     {
12575     case 't':
12576       s_text (0);
12577       break;
12578     case 'd':
12579       s_data (0);
12580       break;
12581     case 'b':
12582       subseg_set (bss_section, (subsegT) get_absolute_expression ());
12583       demand_empty_rest_of_line ();
12584       break;
12585
12586     case 'r':
12587       seg = subseg_new (RDATA_SECTION_NAME,
12588                         (subsegT) get_absolute_expression ());
12589       if (IS_ELF)
12590         {
12591           bfd_set_section_flags (stdoutput, seg, (SEC_ALLOC | SEC_LOAD
12592                                                   | SEC_READONLY | SEC_RELOC
12593                                                   | SEC_DATA));
12594           if (strncmp (TARGET_OS, "elf", 3) != 0)
12595             record_alignment (seg, 4);
12596         }
12597       demand_empty_rest_of_line ();
12598       break;
12599
12600     case 's':
12601       seg = subseg_new (".sdata", (subsegT) get_absolute_expression ());
12602       if (IS_ELF)
12603         {
12604           bfd_set_section_flags (stdoutput, seg,
12605                                  SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA);
12606           if (strncmp (TARGET_OS, "elf", 3) != 0)
12607             record_alignment (seg, 4);
12608         }
12609       demand_empty_rest_of_line ();
12610       break;
12611
12612     case 'B':
12613       seg = subseg_new (".sbss", (subsegT) get_absolute_expression ());
12614       if (IS_ELF)
12615         {
12616           bfd_set_section_flags (stdoutput, seg, SEC_ALLOC);
12617           if (strncmp (TARGET_OS, "elf", 3) != 0)
12618             record_alignment (seg, 4);
12619         }
12620       demand_empty_rest_of_line ();
12621       break;
12622     }
12623
12624   auto_align = 1;
12625 }
12626
12627 void
12628 s_change_section (int ignore ATTRIBUTE_UNUSED)
12629 {
12630 #ifdef OBJ_ELF
12631   char *section_name;
12632   char c;
12633   char next_c = 0;
12634   int section_type;
12635   int section_flag;
12636   int section_entry_size;
12637   int section_alignment;
12638
12639   if (!IS_ELF)
12640     return;
12641
12642   section_name = input_line_pointer;
12643   c = get_symbol_end ();
12644   if (c)
12645     next_c = *(input_line_pointer + 1);
12646
12647   /* Do we have .section Name<,"flags">?  */
12648   if (c != ',' || (c == ',' && next_c == '"'))
12649     {
12650       /* just after name is now '\0'.  */
12651       *input_line_pointer = c;
12652       input_line_pointer = section_name;
12653       obj_elf_section (ignore);
12654       return;
12655     }
12656   input_line_pointer++;
12657
12658   /* Do we have .section Name<,type><,flag><,entry_size><,alignment>  */
12659   if (c == ',')
12660     section_type = get_absolute_expression ();
12661   else
12662     section_type = 0;
12663   if (*input_line_pointer++ == ',')
12664     section_flag = get_absolute_expression ();
12665   else
12666     section_flag = 0;
12667   if (*input_line_pointer++ == ',')
12668     section_entry_size = get_absolute_expression ();
12669   else
12670     section_entry_size = 0;
12671   if (*input_line_pointer++ == ',')
12672     section_alignment = get_absolute_expression ();
12673   else
12674     section_alignment = 0;
12675   /* FIXME: really ignore?  */
12676   (void) section_alignment;
12677
12678   section_name = xstrdup (section_name);
12679
12680   /* When using the generic form of .section (as implemented by obj-elf.c),
12681      there's no way to set the section type to SHT_MIPS_DWARF.  Users have
12682      traditionally had to fall back on the more common @progbits instead.
12683
12684      There's nothing really harmful in this, since bfd will correct
12685      SHT_PROGBITS to SHT_MIPS_DWARF before writing out the file.  But it
12686      means that, for backwards compatibility, the special_section entries
12687      for dwarf sections must use SHT_PROGBITS rather than SHT_MIPS_DWARF.
12688
12689      Even so, we shouldn't force users of the MIPS .section syntax to
12690      incorrectly label the sections as SHT_PROGBITS.  The best compromise
12691      seems to be to map SHT_MIPS_DWARF to SHT_PROGBITS before calling the
12692      generic type-checking code.  */
12693   if (section_type == SHT_MIPS_DWARF)
12694     section_type = SHT_PROGBITS;
12695
12696   obj_elf_change_section (section_name, section_type, section_flag,
12697                           section_entry_size, 0, 0, 0);
12698
12699   if (now_seg->name != section_name)
12700     free (section_name);
12701 #endif /* OBJ_ELF */
12702 }
12703
12704 void
12705 mips_enable_auto_align (void)
12706 {
12707   auto_align = 1;
12708 }
12709
12710 static void
12711 s_cons (int log_size)
12712 {
12713   segment_info_type *si = seg_info (now_seg);
12714   struct insn_label_list *l = si->label_list;
12715   symbolS *label;
12716
12717   label = l != NULL ? l->label : NULL;
12718   mips_emit_delays ();
12719   if (log_size > 0 && auto_align)
12720     mips_align (log_size, 0, label);
12721   mips_clear_insn_labels ();
12722   cons (1 << log_size);
12723 }
12724
12725 static void
12726 s_float_cons (int type)
12727 {
12728   segment_info_type *si = seg_info (now_seg);
12729   struct insn_label_list *l = si->label_list;
12730   symbolS *label;
12731
12732   label = l != NULL ? l->label : NULL;
12733
12734   mips_emit_delays ();
12735
12736   if (auto_align)
12737     {
12738       if (type == 'd')
12739         mips_align (3, 0, label);
12740       else
12741         mips_align (2, 0, label);
12742     }
12743
12744   mips_clear_insn_labels ();
12745
12746   float_cons (type);
12747 }
12748
12749 /* Handle .globl.  We need to override it because on Irix 5 you are
12750    permitted to say
12751        .globl foo .text
12752    where foo is an undefined symbol, to mean that foo should be
12753    considered to be the address of a function.  */
12754
12755 static void
12756 s_mips_globl (int x ATTRIBUTE_UNUSED)
12757 {
12758   char *name;
12759   int c;
12760   symbolS *symbolP;
12761   flagword flag;
12762
12763   do
12764     {
12765       name = input_line_pointer;
12766       c = get_symbol_end ();
12767       symbolP = symbol_find_or_make (name);
12768       S_SET_EXTERNAL (symbolP);
12769
12770       *input_line_pointer = c;
12771       SKIP_WHITESPACE ();
12772
12773       /* On Irix 5, every global symbol that is not explicitly labelled as
12774          being a function is apparently labelled as being an object.  */
12775       flag = BSF_OBJECT;
12776
12777       if (!is_end_of_line[(unsigned char) *input_line_pointer]
12778           && (*input_line_pointer != ','))
12779         {
12780           char *secname;
12781           asection *sec;
12782
12783           secname = input_line_pointer;
12784           c = get_symbol_end ();
12785           sec = bfd_get_section_by_name (stdoutput, secname);
12786           if (sec == NULL)
12787             as_bad (_("%s: no such section"), secname);
12788           *input_line_pointer = c;
12789
12790           if (sec != NULL && (sec->flags & SEC_CODE) != 0)
12791             flag = BSF_FUNCTION;
12792         }
12793
12794       symbol_get_bfdsym (symbolP)->flags |= flag;
12795
12796       c = *input_line_pointer;
12797       if (c == ',')
12798         {
12799           input_line_pointer++;
12800           SKIP_WHITESPACE ();
12801           if (is_end_of_line[(unsigned char) *input_line_pointer])
12802             c = '\n';
12803         }
12804     }
12805   while (c == ',');
12806
12807   demand_empty_rest_of_line ();
12808 }
12809
12810 static void
12811 s_option (int x ATTRIBUTE_UNUSED)
12812 {
12813   char *opt;
12814   char c;
12815
12816   opt = input_line_pointer;
12817   c = get_symbol_end ();
12818
12819   if (*opt == 'O')
12820     {
12821       /* FIXME: What does this mean?  */
12822     }
12823   else if (strncmp (opt, "pic", 3) == 0)
12824     {
12825       int i;
12826
12827       i = atoi (opt + 3);
12828       if (i == 0)
12829         mips_pic = NO_PIC;
12830       else if (i == 2)
12831         {
12832         mips_pic = SVR4_PIC;
12833           mips_abicalls = TRUE;
12834         }
12835       else
12836         as_bad (_(".option pic%d not supported"), i);
12837
12838       if (mips_pic == SVR4_PIC)
12839         {
12840           if (g_switch_seen && g_switch_value != 0)
12841             as_warn (_("-G may not be used with SVR4 PIC code"));
12842           g_switch_value = 0;
12843           bfd_set_gp_size (stdoutput, 0);
12844         }
12845     }
12846   else
12847     as_warn (_("Unrecognized option \"%s\""), opt);
12848
12849   *input_line_pointer = c;
12850   demand_empty_rest_of_line ();
12851 }
12852
12853 /* This structure is used to hold a stack of .set values.  */
12854
12855 struct mips_option_stack
12856 {
12857   struct mips_option_stack *next;
12858   struct mips_set_options options;
12859 };
12860
12861 static struct mips_option_stack *mips_opts_stack;
12862
12863 /* Handle the .set pseudo-op.  */
12864
12865 static void
12866 s_mipsset (int x ATTRIBUTE_UNUSED)
12867 {
12868   char *name = input_line_pointer, ch;
12869
12870   while (!is_end_of_line[(unsigned char) *input_line_pointer])
12871     ++input_line_pointer;
12872   ch = *input_line_pointer;
12873   *input_line_pointer = '\0';
12874
12875   if (strcmp (name, "reorder") == 0)
12876     {
12877       if (mips_opts.noreorder)
12878         end_noreorder ();
12879     }
12880   else if (strcmp (name, "noreorder") == 0)
12881     {
12882       if (!mips_opts.noreorder)
12883         start_noreorder ();
12884     }
12885   else if (strncmp (name, "at=", 3) == 0)
12886     {
12887       char *s = name + 3;
12888
12889       if (!reg_lookup (&s, RTYPE_NUM | RTYPE_GP, &mips_opts.at))
12890         as_bad (_("Unrecognized register name `%s'"), s);
12891     }
12892   else if (strcmp (name, "at") == 0)
12893     {
12894       mips_opts.at = ATREG;
12895     }
12896   else if (strcmp (name, "noat") == 0)
12897     {
12898       mips_opts.at = ZERO;
12899     }
12900   else if (strcmp (name, "macro") == 0)
12901     {
12902       mips_opts.warn_about_macros = 0;
12903     }
12904   else if (strcmp (name, "nomacro") == 0)
12905     {
12906       if (mips_opts.noreorder == 0)
12907         as_bad (_("`noreorder' must be set before `nomacro'"));
12908       mips_opts.warn_about_macros = 1;
12909     }
12910   else if (strcmp (name, "move") == 0 || strcmp (name, "novolatile") == 0)
12911     {
12912       mips_opts.nomove = 0;
12913     }
12914   else if (strcmp (name, "nomove") == 0 || strcmp (name, "volatile") == 0)
12915     {
12916       mips_opts.nomove = 1;
12917     }
12918   else if (strcmp (name, "bopt") == 0)
12919     {
12920       mips_opts.nobopt = 0;
12921     }
12922   else if (strcmp (name, "nobopt") == 0)
12923     {
12924       mips_opts.nobopt = 1;
12925     }
12926   else if (strcmp (name, "gp=default") == 0)
12927     mips_opts.gp32 = file_mips_gp32;
12928   else if (strcmp (name, "gp=32") == 0)
12929     mips_opts.gp32 = 1;
12930   else if (strcmp (name, "gp=64") == 0)
12931     {
12932       if (!ISA_HAS_64BIT_REGS (mips_opts.isa))
12933         as_warn (_("%s isa does not support 64-bit registers"),
12934                  mips_cpu_info_from_isa (mips_opts.isa)->name);
12935       mips_opts.gp32 = 0;
12936     }
12937   else if (strcmp (name, "fp=default") == 0)
12938     mips_opts.fp32 = file_mips_fp32;
12939   else if (strcmp (name, "fp=32") == 0)
12940     mips_opts.fp32 = 1;
12941   else if (strcmp (name, "fp=64") == 0)
12942     {
12943       if (!ISA_HAS_64BIT_FPRS (mips_opts.isa))
12944         as_warn (_("%s isa does not support 64-bit floating point registers"),
12945                  mips_cpu_info_from_isa (mips_opts.isa)->name);
12946       mips_opts.fp32 = 0;
12947     }
12948   else if (strcmp (name, "softfloat") == 0)
12949     mips_opts.soft_float = 1;
12950   else if (strcmp (name, "hardfloat") == 0)
12951     mips_opts.soft_float = 0;
12952   else if (strcmp (name, "singlefloat") == 0)
12953     mips_opts.single_float = 1;
12954   else if (strcmp (name, "doublefloat") == 0)
12955     mips_opts.single_float = 0;
12956   else if (strcmp (name, "mips16") == 0
12957            || strcmp (name, "MIPS-16") == 0)
12958     mips_opts.mips16 = 1;
12959   else if (strcmp (name, "nomips16") == 0
12960            || strcmp (name, "noMIPS-16") == 0)
12961     mips_opts.mips16 = 0;
12962   else if (strcmp (name, "smartmips") == 0)
12963     {
12964       if (!ISA_SUPPORTS_SMARTMIPS)
12965         as_warn (_("%s ISA does not support SmartMIPS ASE"), 
12966                  mips_cpu_info_from_isa (mips_opts.isa)->name);
12967       mips_opts.ase_smartmips = 1;
12968     }
12969   else if (strcmp (name, "nosmartmips") == 0)
12970     mips_opts.ase_smartmips = 0;
12971   else if (strcmp (name, "mips3d") == 0)
12972     mips_opts.ase_mips3d = 1;
12973   else if (strcmp (name, "nomips3d") == 0)
12974     mips_opts.ase_mips3d = 0;
12975   else if (strcmp (name, "mdmx") == 0)
12976     mips_opts.ase_mdmx = 1;
12977   else if (strcmp (name, "nomdmx") == 0)
12978     mips_opts.ase_mdmx = 0;
12979   else if (strcmp (name, "dsp") == 0)
12980     {
12981       if (!ISA_SUPPORTS_DSP_ASE)
12982         as_warn (_("%s ISA does not support DSP ASE"), 
12983                  mips_cpu_info_from_isa (mips_opts.isa)->name);
12984       mips_opts.ase_dsp = 1;
12985       mips_opts.ase_dspr2 = 0;
12986     }
12987   else if (strcmp (name, "nodsp") == 0)
12988     {
12989       mips_opts.ase_dsp = 0;
12990       mips_opts.ase_dspr2 = 0;
12991     }
12992   else if (strcmp (name, "dspr2") == 0)
12993     {
12994       if (!ISA_SUPPORTS_DSPR2_ASE)
12995         as_warn (_("%s ISA does not support DSP R2 ASE"),
12996                  mips_cpu_info_from_isa (mips_opts.isa)->name);
12997       mips_opts.ase_dspr2 = 1;
12998       mips_opts.ase_dsp = 1;
12999     }
13000   else if (strcmp (name, "nodspr2") == 0)
13001     {
13002       mips_opts.ase_dspr2 = 0;
13003       mips_opts.ase_dsp = 0;
13004     }
13005   else if (strcmp (name, "mt") == 0)
13006     {
13007       if (!ISA_SUPPORTS_MT_ASE)
13008         as_warn (_("%s ISA does not support MT ASE"), 
13009                  mips_cpu_info_from_isa (mips_opts.isa)->name);
13010       mips_opts.ase_mt = 1;
13011     }
13012   else if (strcmp (name, "nomt") == 0)
13013     mips_opts.ase_mt = 0;
13014   else if (strncmp (name, "mips", 4) == 0 || strncmp (name, "arch=", 5) == 0)
13015     {
13016       int reset = 0;
13017
13018       /* Permit the user to change the ISA and architecture on the fly.
13019          Needless to say, misuse can cause serious problems.  */
13020       if (strcmp (name, "mips0") == 0 || strcmp (name, "arch=default") == 0)
13021         {
13022           reset = 1;
13023           mips_opts.isa = file_mips_isa;
13024           mips_opts.arch = file_mips_arch;
13025         }
13026       else if (strncmp (name, "arch=", 5) == 0)
13027         {
13028           const struct mips_cpu_info *p;
13029
13030           p = mips_parse_cpu("internal use", name + 5);
13031           if (!p)
13032             as_bad (_("unknown architecture %s"), name + 5);
13033           else
13034             {
13035               mips_opts.arch = p->cpu;
13036               mips_opts.isa = p->isa;
13037             }
13038         }
13039       else if (strncmp (name, "mips", 4) == 0)
13040         {
13041           const struct mips_cpu_info *p;
13042
13043           p = mips_parse_cpu("internal use", name);
13044           if (!p)
13045             as_bad (_("unknown ISA level %s"), name + 4);
13046           else
13047             {
13048               mips_opts.arch = p->cpu;
13049               mips_opts.isa = p->isa;
13050             }
13051         }
13052       else
13053         as_bad (_("unknown ISA or architecture %s"), name);
13054
13055       switch (mips_opts.isa)
13056         {
13057         case  0:
13058           break;
13059         case ISA_MIPS1:
13060         case ISA_MIPS2:
13061         case ISA_MIPS32:
13062         case ISA_MIPS32R2:
13063           mips_opts.gp32 = 1;
13064           mips_opts.fp32 = 1;
13065           break;
13066         case ISA_MIPS3:
13067         case ISA_MIPS4:
13068         case ISA_MIPS5:
13069         case ISA_MIPS64:
13070         case ISA_MIPS64R2:
13071           mips_opts.gp32 = 0;
13072           mips_opts.fp32 = 0;
13073           break;
13074         default:
13075           as_bad (_("unknown ISA level %s"), name + 4);
13076           break;
13077         }
13078       if (reset)
13079         {
13080           mips_opts.gp32 = file_mips_gp32;
13081           mips_opts.fp32 = file_mips_fp32;
13082         }
13083     }
13084   else if (strcmp (name, "autoextend") == 0)
13085     mips_opts.noautoextend = 0;
13086   else if (strcmp (name, "noautoextend") == 0)
13087     mips_opts.noautoextend = 1;
13088   else if (strcmp (name, "push") == 0)
13089     {
13090       struct mips_option_stack *s;
13091
13092       s = (struct mips_option_stack *) xmalloc (sizeof *s);
13093       s->next = mips_opts_stack;
13094       s->options = mips_opts;
13095       mips_opts_stack = s;
13096     }
13097   else if (strcmp (name, "pop") == 0)
13098     {
13099       struct mips_option_stack *s;
13100
13101       s = mips_opts_stack;
13102       if (s == NULL)
13103         as_bad (_(".set pop with no .set push"));
13104       else
13105         {
13106           /* If we're changing the reorder mode we need to handle
13107              delay slots correctly.  */
13108           if (s->options.noreorder && ! mips_opts.noreorder)
13109             start_noreorder ();
13110           else if (! s->options.noreorder && mips_opts.noreorder)
13111             end_noreorder ();
13112
13113           mips_opts = s->options;
13114           mips_opts_stack = s->next;
13115           free (s);
13116         }
13117     }
13118   else if (strcmp (name, "sym32") == 0)
13119     mips_opts.sym32 = TRUE;
13120   else if (strcmp (name, "nosym32") == 0)
13121     mips_opts.sym32 = FALSE;
13122   else if (strchr (name, ','))
13123     {
13124       /* Generic ".set" directive; use the generic handler.  */
13125       *input_line_pointer = ch;
13126       input_line_pointer = name;
13127       s_set (0);
13128       return;
13129     }
13130   else
13131     {
13132       as_warn (_("Tried to set unrecognized symbol: %s\n"), name);
13133     }
13134   *input_line_pointer = ch;
13135   demand_empty_rest_of_line ();
13136 }
13137
13138 /* Handle the .abicalls pseudo-op.  I believe this is equivalent to
13139    .option pic2.  It means to generate SVR4 PIC calls.  */
13140
13141 static void
13142 s_abicalls (int ignore ATTRIBUTE_UNUSED)
13143 {
13144   mips_pic = SVR4_PIC;
13145   mips_abicalls = TRUE;
13146
13147   if (g_switch_seen && g_switch_value != 0)
13148     as_warn (_("-G may not be used with SVR4 PIC code"));
13149   g_switch_value = 0;
13150
13151   bfd_set_gp_size (stdoutput, 0);
13152   demand_empty_rest_of_line ();
13153 }
13154
13155 /* Handle the .cpload pseudo-op.  This is used when generating SVR4
13156    PIC code.  It sets the $gp register for the function based on the
13157    function address, which is in the register named in the argument.
13158    This uses a relocation against _gp_disp, which is handled specially
13159    by the linker.  The result is:
13160         lui     $gp,%hi(_gp_disp)
13161         addiu   $gp,$gp,%lo(_gp_disp)
13162         addu    $gp,$gp,.cpload argument
13163    The .cpload argument is normally $25 == $t9.
13164
13165    The -mno-shared option changes this to:
13166         lui     $gp,%hi(__gnu_local_gp)
13167         addiu   $gp,$gp,%lo(__gnu_local_gp)
13168    and the argument is ignored.  This saves an instruction, but the
13169    resulting code is not position independent; it uses an absolute
13170    address for __gnu_local_gp.  Thus code assembled with -mno-shared
13171    can go into an ordinary executable, but not into a shared library.  */
13172
13173 static void
13174 s_cpload (int ignore ATTRIBUTE_UNUSED)
13175 {
13176   expressionS ex;
13177   int reg;
13178   int in_shared;
13179
13180   /* If we are not generating SVR4 PIC code, or if this is NewABI code,
13181      .cpload is ignored.  */
13182   if (mips_pic != SVR4_PIC || HAVE_NEWABI)
13183     {
13184       s_ignore (0);
13185       return;
13186     }
13187
13188   /* .cpload should be in a .set noreorder section.  */
13189   if (mips_opts.noreorder == 0)
13190     as_warn (_(".cpload not in noreorder section"));
13191
13192   reg = tc_get_register (0);
13193
13194   /* If we need to produce a 64-bit address, we are better off using
13195      the default instruction sequence.  */
13196   in_shared = mips_in_shared || HAVE_64BIT_SYMBOLS;
13197
13198   ex.X_op = O_symbol;
13199   ex.X_add_symbol = symbol_find_or_make (in_shared ? "_gp_disp" :
13200                                          "__gnu_local_gp");
13201   ex.X_op_symbol = NULL;
13202   ex.X_add_number = 0;
13203
13204   /* In ELF, this symbol is implicitly an STT_OBJECT symbol.  */
13205   symbol_get_bfdsym (ex.X_add_symbol)->flags |= BSF_OBJECT;
13206
13207   macro_start ();
13208   macro_build_lui (&ex, mips_gp_register);
13209   macro_build (&ex, "addiu", "t,r,j", mips_gp_register,
13210                mips_gp_register, BFD_RELOC_LO16);
13211   if (in_shared)
13212     macro_build (NULL, "addu", "d,v,t", mips_gp_register,
13213                  mips_gp_register, reg);
13214   macro_end ();
13215
13216   demand_empty_rest_of_line ();
13217 }
13218
13219 /* Handle the .cpsetup pseudo-op defined for NewABI PIC code.  The syntax is:
13220      .cpsetup $reg1, offset|$reg2, label
13221
13222    If offset is given, this results in:
13223      sd         $gp, offset($sp)
13224      lui        $gp, %hi(%neg(%gp_rel(label)))
13225      addiu      $gp, $gp, %lo(%neg(%gp_rel(label)))
13226      daddu      $gp, $gp, $reg1
13227
13228    If $reg2 is given, this results in:
13229      daddu      $reg2, $gp, $0
13230      lui        $gp, %hi(%neg(%gp_rel(label)))
13231      addiu      $gp, $gp, %lo(%neg(%gp_rel(label)))
13232      daddu      $gp, $gp, $reg1
13233    $reg1 is normally $25 == $t9.
13234
13235    The -mno-shared option replaces the last three instructions with
13236         lui     $gp,%hi(_gp)
13237         addiu   $gp,$gp,%lo(_gp)  */
13238
13239 static void
13240 s_cpsetup (int ignore ATTRIBUTE_UNUSED)
13241 {
13242   expressionS ex_off;
13243   expressionS ex_sym;
13244   int reg1;
13245
13246   /* If we are not generating SVR4 PIC code, .cpsetup is ignored.
13247      We also need NewABI support.  */
13248   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
13249     {
13250       s_ignore (0);
13251       return;
13252     }
13253
13254   reg1 = tc_get_register (0);
13255   SKIP_WHITESPACE ();
13256   if (*input_line_pointer != ',')
13257     {
13258       as_bad (_("missing argument separator ',' for .cpsetup"));
13259       return;
13260     }
13261   else
13262     ++input_line_pointer;
13263   SKIP_WHITESPACE ();
13264   if (*input_line_pointer == '$')
13265     {
13266       mips_cpreturn_register = tc_get_register (0);
13267       mips_cpreturn_offset = -1;
13268     }
13269   else
13270     {
13271       mips_cpreturn_offset = get_absolute_expression ();
13272       mips_cpreturn_register = -1;
13273     }
13274   SKIP_WHITESPACE ();
13275   if (*input_line_pointer != ',')
13276     {
13277       as_bad (_("missing argument separator ',' for .cpsetup"));
13278       return;
13279     }
13280   else
13281     ++input_line_pointer;
13282   SKIP_WHITESPACE ();
13283   expression (&ex_sym);
13284
13285   macro_start ();
13286   if (mips_cpreturn_register == -1)
13287     {
13288       ex_off.X_op = O_constant;
13289       ex_off.X_add_symbol = NULL;
13290       ex_off.X_op_symbol = NULL;
13291       ex_off.X_add_number = mips_cpreturn_offset;
13292
13293       macro_build (&ex_off, "sd", "t,o(b)", mips_gp_register,
13294                    BFD_RELOC_LO16, SP);
13295     }
13296   else
13297     macro_build (NULL, "daddu", "d,v,t", mips_cpreturn_register,
13298                  mips_gp_register, 0);
13299
13300   if (mips_in_shared || HAVE_64BIT_SYMBOLS)
13301     {
13302       macro_build (&ex_sym, "lui", "t,u", mips_gp_register,
13303                    -1, BFD_RELOC_GPREL16, BFD_RELOC_MIPS_SUB,
13304                    BFD_RELOC_HI16_S);
13305
13306       macro_build (&ex_sym, "addiu", "t,r,j", mips_gp_register,
13307                    mips_gp_register, -1, BFD_RELOC_GPREL16,
13308                    BFD_RELOC_MIPS_SUB, BFD_RELOC_LO16);
13309
13310       macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", mips_gp_register,
13311                    mips_gp_register, reg1);
13312     }
13313   else
13314     {
13315       expressionS ex;
13316
13317       ex.X_op = O_symbol;
13318       ex.X_add_symbol = symbol_find_or_make ("__gnu_local_gp");
13319       ex.X_op_symbol = NULL;
13320       ex.X_add_number = 0;
13321
13322       /* In ELF, this symbol is implicitly an STT_OBJECT symbol.  */
13323       symbol_get_bfdsym (ex.X_add_symbol)->flags |= BSF_OBJECT;
13324
13325       macro_build_lui (&ex, mips_gp_register);
13326       macro_build (&ex, "addiu", "t,r,j", mips_gp_register,
13327                    mips_gp_register, BFD_RELOC_LO16);
13328     }
13329
13330   macro_end ();
13331
13332   demand_empty_rest_of_line ();
13333 }
13334
13335 static void
13336 s_cplocal (int ignore ATTRIBUTE_UNUSED)
13337 {
13338   /* If we are not generating SVR4 PIC code, or if this is not NewABI code,
13339      .cplocal is ignored.  */
13340   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
13341     {
13342       s_ignore (0);
13343       return;
13344     }
13345
13346   mips_gp_register = tc_get_register (0);
13347   demand_empty_rest_of_line ();
13348 }
13349
13350 /* Handle the .cprestore pseudo-op.  This stores $gp into a given
13351    offset from $sp.  The offset is remembered, and after making a PIC
13352    call $gp is restored from that location.  */
13353
13354 static void
13355 s_cprestore (int ignore ATTRIBUTE_UNUSED)
13356 {
13357   expressionS ex;
13358
13359   /* If we are not generating SVR4 PIC code, or if this is NewABI code,
13360      .cprestore is ignored.  */
13361   if (mips_pic != SVR4_PIC || HAVE_NEWABI)
13362     {
13363       s_ignore (0);
13364       return;
13365     }
13366
13367   mips_cprestore_offset = get_absolute_expression ();
13368   mips_cprestore_valid = 1;
13369
13370   ex.X_op = O_constant;
13371   ex.X_add_symbol = NULL;
13372   ex.X_op_symbol = NULL;
13373   ex.X_add_number = mips_cprestore_offset;
13374
13375   macro_start ();
13376   macro_build_ldst_constoffset (&ex, ADDRESS_STORE_INSN, mips_gp_register,
13377                                 SP, HAVE_64BIT_ADDRESSES);
13378   macro_end ();
13379
13380   demand_empty_rest_of_line ();
13381 }
13382
13383 /* Handle the .cpreturn pseudo-op defined for NewABI PIC code. If an offset
13384    was given in the preceding .cpsetup, it results in:
13385      ld         $gp, offset($sp)
13386
13387    If a register $reg2 was given there, it results in:
13388      daddu      $gp, $reg2, $0  */
13389
13390 static void
13391 s_cpreturn (int ignore ATTRIBUTE_UNUSED)
13392 {
13393   expressionS ex;
13394
13395   /* If we are not generating SVR4 PIC code, .cpreturn is ignored.
13396      We also need NewABI support.  */
13397   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
13398     {
13399       s_ignore (0);
13400       return;
13401     }
13402
13403   macro_start ();
13404   if (mips_cpreturn_register == -1)
13405     {
13406       ex.X_op = O_constant;
13407       ex.X_add_symbol = NULL;
13408       ex.X_op_symbol = NULL;
13409       ex.X_add_number = mips_cpreturn_offset;
13410
13411       macro_build (&ex, "ld", "t,o(b)", mips_gp_register, BFD_RELOC_LO16, SP);
13412     }
13413   else
13414     macro_build (NULL, "daddu", "d,v,t", mips_gp_register,
13415                  mips_cpreturn_register, 0);
13416   macro_end ();
13417
13418   demand_empty_rest_of_line ();
13419 }
13420
13421 /* Handle the .dtprelword and .dtpreldword pseudo-ops.  They generate
13422    a 32-bit or 64-bit DTP-relative relocation (BYTES says which) for
13423    use in DWARF debug information.  */
13424
13425 static void
13426 s_dtprel_internal (size_t bytes)
13427 {
13428   expressionS ex;
13429   char *p;
13430
13431   expression (&ex);
13432
13433   if (ex.X_op != O_symbol)
13434     {
13435       as_bad (_("Unsupported use of %s"), (bytes == 8
13436                                            ? ".dtpreldword"
13437                                            : ".dtprelword"));
13438       ignore_rest_of_line ();
13439     }
13440
13441   p = frag_more (bytes);
13442   md_number_to_chars (p, 0, bytes);
13443   fix_new_exp (frag_now, p - frag_now->fr_literal, bytes, &ex, FALSE,
13444                (bytes == 8
13445                 ? BFD_RELOC_MIPS_TLS_DTPREL64
13446                 : BFD_RELOC_MIPS_TLS_DTPREL32));
13447
13448   demand_empty_rest_of_line ();
13449 }
13450
13451 /* Handle .dtprelword.  */
13452
13453 static void
13454 s_dtprelword (int ignore ATTRIBUTE_UNUSED)
13455 {
13456   s_dtprel_internal (4);
13457 }
13458
13459 /* Handle .dtpreldword.  */
13460
13461 static void
13462 s_dtpreldword (int ignore ATTRIBUTE_UNUSED)
13463 {
13464   s_dtprel_internal (8);
13465 }
13466
13467 /* Handle the .gpvalue pseudo-op.  This is used when generating NewABI PIC
13468    code.  It sets the offset to use in gp_rel relocations.  */
13469
13470 static void
13471 s_gpvalue (int ignore ATTRIBUTE_UNUSED)
13472 {
13473   /* If we are not generating SVR4 PIC code, .gpvalue is ignored.
13474      We also need NewABI support.  */
13475   if (mips_pic != SVR4_PIC || ! HAVE_NEWABI)
13476     {
13477       s_ignore (0);
13478       return;
13479     }
13480
13481   mips_gprel_offset = get_absolute_expression ();
13482
13483   demand_empty_rest_of_line ();
13484 }
13485
13486 /* Handle the .gpword pseudo-op.  This is used when generating PIC
13487    code.  It generates a 32 bit GP relative reloc.  */
13488
13489 static void
13490 s_gpword (int ignore ATTRIBUTE_UNUSED)
13491 {
13492   segment_info_type *si;
13493   struct insn_label_list *l;
13494   symbolS *label;
13495   expressionS ex;
13496   char *p;
13497
13498   /* When not generating PIC code, this is treated as .word.  */
13499   if (mips_pic != SVR4_PIC)
13500     {
13501       s_cons (2);
13502       return;
13503     }
13504
13505   si = seg_info (now_seg);
13506   l = si->label_list;
13507   label = l != NULL ? l->label : NULL;
13508   mips_emit_delays ();
13509   if (auto_align)
13510     mips_align (2, 0, label);
13511   mips_clear_insn_labels ();
13512
13513   expression (&ex);
13514
13515   if (ex.X_op != O_symbol || ex.X_add_number != 0)
13516     {
13517       as_bad (_("Unsupported use of .gpword"));
13518       ignore_rest_of_line ();
13519     }
13520
13521   p = frag_more (4);
13522   md_number_to_chars (p, 0, 4);
13523   fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &ex, FALSE,
13524                BFD_RELOC_GPREL32);
13525
13526   demand_empty_rest_of_line ();
13527 }
13528
13529 static void
13530 s_gpdword (int ignore ATTRIBUTE_UNUSED)
13531 {
13532   segment_info_type *si;
13533   struct insn_label_list *l;
13534   symbolS *label;
13535   expressionS ex;
13536   char *p;
13537
13538   /* When not generating PIC code, this is treated as .dword.  */
13539   if (mips_pic != SVR4_PIC)
13540     {
13541       s_cons (3);
13542       return;
13543     }
13544
13545   si = seg_info (now_seg);
13546   l = si->label_list;
13547   label = l != NULL ? l->label : NULL;
13548   mips_emit_delays ();
13549   if (auto_align)
13550     mips_align (3, 0, label);
13551   mips_clear_insn_labels ();
13552
13553   expression (&ex);
13554
13555   if (ex.X_op != O_symbol || ex.X_add_number != 0)
13556     {
13557       as_bad (_("Unsupported use of .gpdword"));
13558       ignore_rest_of_line ();
13559     }
13560
13561   p = frag_more (8);
13562   md_number_to_chars (p, 0, 8);
13563   fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &ex, FALSE,
13564                BFD_RELOC_GPREL32)->fx_tcbit = 1;
13565
13566   /* GPREL32 composed with 64 gives a 64-bit GP offset.  */
13567   fix_new (frag_now, p - frag_now->fr_literal, 8, NULL, 0,
13568            FALSE, BFD_RELOC_64)->fx_tcbit = 1;
13569
13570   demand_empty_rest_of_line ();
13571 }
13572
13573 /* Handle the .cpadd pseudo-op.  This is used when dealing with switch
13574    tables in SVR4 PIC code.  */
13575
13576 static void
13577 s_cpadd (int ignore ATTRIBUTE_UNUSED)
13578 {
13579   int reg;
13580
13581   /* This is ignored when not generating SVR4 PIC code.  */
13582   if (mips_pic != SVR4_PIC)
13583     {
13584       s_ignore (0);
13585       return;
13586     }
13587
13588   /* Add $gp to the register named as an argument.  */
13589   macro_start ();
13590   reg = tc_get_register (0);
13591   macro_build (NULL, ADDRESS_ADD_INSN, "d,v,t", reg, reg, mips_gp_register);
13592   macro_end ();
13593
13594   demand_empty_rest_of_line ();
13595 }
13596
13597 /* Handle the .insn pseudo-op.  This marks instruction labels in
13598    mips16 mode.  This permits the linker to handle them specially,
13599    such as generating jalx instructions when needed.  We also make
13600    them odd for the duration of the assembly, in order to generate the
13601    right sort of code.  We will make them even in the adjust_symtab
13602    routine, while leaving them marked.  This is convenient for the
13603    debugger and the disassembler.  The linker knows to make them odd
13604    again.  */
13605
13606 static void
13607 s_insn (int ignore ATTRIBUTE_UNUSED)
13608 {
13609   mips16_mark_labels ();
13610
13611   demand_empty_rest_of_line ();
13612 }
13613
13614 /* Handle a .stabn directive.  We need these in order to mark a label
13615    as being a mips16 text label correctly.  Sometimes the compiler
13616    will emit a label, followed by a .stabn, and then switch sections.
13617    If the label and .stabn are in mips16 mode, then the label is
13618    really a mips16 text label.  */
13619
13620 static void
13621 s_mips_stab (int type)
13622 {
13623   if (type == 'n')
13624     mips16_mark_labels ();
13625
13626   s_stab (type);
13627 }
13628
13629 /* Handle the .weakext pseudo-op as defined in Kane and Heinrich.  */
13630
13631 static void
13632 s_mips_weakext (int ignore ATTRIBUTE_UNUSED)
13633 {
13634   char *name;
13635   int c;
13636   symbolS *symbolP;
13637   expressionS exp;
13638
13639   name = input_line_pointer;
13640   c = get_symbol_end ();
13641   symbolP = symbol_find_or_make (name);
13642   S_SET_WEAK (symbolP);
13643   *input_line_pointer = c;
13644
13645   SKIP_WHITESPACE ();
13646
13647   if (! is_end_of_line[(unsigned char) *input_line_pointer])
13648     {
13649       if (S_IS_DEFINED (symbolP))
13650         {
13651           as_bad (_("ignoring attempt to redefine symbol %s"),
13652                   S_GET_NAME (symbolP));
13653           ignore_rest_of_line ();
13654           return;
13655         }
13656
13657       if (*input_line_pointer == ',')
13658         {
13659           ++input_line_pointer;
13660           SKIP_WHITESPACE ();
13661         }
13662
13663       expression (&exp);
13664       if (exp.X_op != O_symbol)
13665         {
13666           as_bad (_("bad .weakext directive"));
13667           ignore_rest_of_line ();
13668           return;
13669         }
13670       symbol_set_value_expression (symbolP, &exp);
13671     }
13672
13673   demand_empty_rest_of_line ();
13674 }
13675
13676 /* Parse a register string into a number.  Called from the ECOFF code
13677    to parse .frame.  The argument is non-zero if this is the frame
13678    register, so that we can record it in mips_frame_reg.  */
13679
13680 int
13681 tc_get_register (int frame)
13682 {
13683   unsigned int reg;
13684
13685   SKIP_WHITESPACE ();
13686   if (! reg_lookup (&input_line_pointer, RWARN | RTYPE_NUM | RTYPE_GP, &reg))
13687     reg = 0;
13688   if (frame)
13689     {
13690       mips_frame_reg = reg != 0 ? reg : SP;
13691       mips_frame_reg_valid = 1;
13692       mips_cprestore_valid = 0;
13693     }
13694   return reg;
13695 }
13696
13697 valueT
13698 md_section_align (asection *seg, valueT addr)
13699 {
13700   int align = bfd_get_section_alignment (stdoutput, seg);
13701
13702   if (IS_ELF)
13703     {
13704       /* We don't need to align ELF sections to the full alignment.
13705          However, Irix 5 may prefer that we align them at least to a 16
13706          byte boundary.  We don't bother to align the sections if we
13707          are targeted for an embedded system.  */
13708       if (strncmp (TARGET_OS, "elf", 3) == 0)
13709         return addr;
13710       if (align > 4)
13711         align = 4;
13712     }
13713
13714   return ((addr + (1 << align) - 1) & (-1 << align));
13715 }
13716
13717 /* Utility routine, called from above as well.  If called while the
13718    input file is still being read, it's only an approximation.  (For
13719    example, a symbol may later become defined which appeared to be
13720    undefined earlier.)  */
13721
13722 static int
13723 nopic_need_relax (symbolS *sym, int before_relaxing)
13724 {
13725   if (sym == 0)
13726     return 0;
13727
13728   if (g_switch_value > 0)
13729     {
13730       const char *symname;
13731       int change;
13732
13733       /* Find out whether this symbol can be referenced off the $gp
13734          register.  It can be if it is smaller than the -G size or if
13735          it is in the .sdata or .sbss section.  Certain symbols can
13736          not be referenced off the $gp, although it appears as though
13737          they can.  */
13738       symname = S_GET_NAME (sym);
13739       if (symname != (const char *) NULL
13740           && (strcmp (symname, "eprol") == 0
13741               || strcmp (symname, "etext") == 0
13742               || strcmp (symname, "_gp") == 0
13743               || strcmp (symname, "edata") == 0
13744               || strcmp (symname, "_fbss") == 0
13745               || strcmp (symname, "_fdata") == 0
13746               || strcmp (symname, "_ftext") == 0
13747               || strcmp (symname, "end") == 0
13748               || strcmp (symname, "_gp_disp") == 0))
13749         change = 1;
13750       else if ((! S_IS_DEFINED (sym) || S_IS_COMMON (sym))
13751                && (0
13752 #ifndef NO_ECOFF_DEBUGGING
13753                    || (symbol_get_obj (sym)->ecoff_extern_size != 0
13754                        && (symbol_get_obj (sym)->ecoff_extern_size
13755                            <= g_switch_value))
13756 #endif
13757                    /* We must defer this decision until after the whole
13758                       file has been read, since there might be a .extern
13759                       after the first use of this symbol.  */
13760                    || (before_relaxing
13761 #ifndef NO_ECOFF_DEBUGGING
13762                        && symbol_get_obj (sym)->ecoff_extern_size == 0
13763 #endif
13764                        && S_GET_VALUE (sym) == 0)
13765                    || (S_GET_VALUE (sym) != 0
13766                        && S_GET_VALUE (sym) <= g_switch_value)))
13767         change = 0;
13768       else
13769         {
13770           const char *segname;
13771
13772           segname = segment_name (S_GET_SEGMENT (sym));
13773           gas_assert (strcmp (segname, ".lit8") != 0
13774                   && strcmp (segname, ".lit4") != 0);
13775           change = (strcmp (segname, ".sdata") != 0
13776                     && strcmp (segname, ".sbss") != 0
13777                     && strncmp (segname, ".sdata.", 7) != 0
13778                     && strncmp (segname, ".sbss.", 6) != 0
13779                     && strncmp (segname, ".gnu.linkonce.sb.", 17) != 0
13780                     && strncmp (segname, ".gnu.linkonce.s.", 16) != 0);
13781         }
13782       return change;
13783     }
13784   else
13785     /* We are not optimizing for the $gp register.  */
13786     return 1;
13787 }
13788
13789
13790 /* Return true if the given symbol should be considered local for SVR4 PIC.  */
13791
13792 static bfd_boolean
13793 pic_need_relax (symbolS *sym, asection *segtype)
13794 {
13795   asection *symsec;
13796
13797   /* Handle the case of a symbol equated to another symbol.  */
13798   while (symbol_equated_reloc_p (sym))
13799     {
13800       symbolS *n;
13801
13802       /* It's possible to get a loop here in a badly written program.  */
13803       n = symbol_get_value_expression (sym)->X_add_symbol;
13804       if (n == sym)
13805         break;
13806       sym = n;
13807     }
13808
13809   if (symbol_section_p (sym))
13810     return TRUE;
13811
13812   symsec = S_GET_SEGMENT (sym);
13813
13814   /* This must duplicate the test in adjust_reloc_syms.  */
13815   return (symsec != &bfd_und_section
13816           && symsec != &bfd_abs_section
13817           && !bfd_is_com_section (symsec)
13818           && !s_is_linkonce (sym, segtype)
13819 #ifdef OBJ_ELF
13820           /* A global or weak symbol is treated as external.  */
13821           && (!IS_ELF || (! S_IS_WEAK (sym) && ! S_IS_EXTERNAL (sym)))
13822 #endif
13823           );
13824 }
13825
13826
13827 /* Given a mips16 variant frag FRAGP, return non-zero if it needs an
13828    extended opcode.  SEC is the section the frag is in.  */
13829
13830 static int
13831 mips16_extended_frag (fragS *fragp, asection *sec, long stretch)
13832 {
13833   int type;
13834   const struct mips16_immed_operand *op;
13835   offsetT val;
13836   int mintiny, maxtiny;
13837   segT symsec;
13838   fragS *sym_frag;
13839
13840   if (RELAX_MIPS16_USER_SMALL (fragp->fr_subtype))
13841     return 0;
13842   if (RELAX_MIPS16_USER_EXT (fragp->fr_subtype))
13843     return 1;
13844
13845   type = RELAX_MIPS16_TYPE (fragp->fr_subtype);
13846   op = mips16_immed_operands;
13847   while (op->type != type)
13848     {
13849       ++op;
13850       gas_assert (op < mips16_immed_operands + MIPS16_NUM_IMMED);
13851     }
13852
13853   if (op->unsp)
13854     {
13855       if (type == '<' || type == '>' || type == '[' || type == ']')
13856         {
13857           mintiny = 1;
13858           maxtiny = 1 << op->nbits;
13859         }
13860       else
13861         {
13862           mintiny = 0;
13863           maxtiny = (1 << op->nbits) - 1;
13864         }
13865     }
13866   else
13867     {
13868       mintiny = - (1 << (op->nbits - 1));
13869       maxtiny = (1 << (op->nbits - 1)) - 1;
13870     }
13871
13872   sym_frag = symbol_get_frag (fragp->fr_symbol);
13873   val = S_GET_VALUE (fragp->fr_symbol);
13874   symsec = S_GET_SEGMENT (fragp->fr_symbol);
13875
13876   if (op->pcrel)
13877     {
13878       addressT addr;
13879
13880       /* We won't have the section when we are called from
13881          mips_relax_frag.  However, we will always have been called
13882          from md_estimate_size_before_relax first.  If this is a
13883          branch to a different section, we mark it as such.  If SEC is
13884          NULL, and the frag is not marked, then it must be a branch to
13885          the same section.  */
13886       if (sec == NULL)
13887         {
13888           if (RELAX_MIPS16_LONG_BRANCH (fragp->fr_subtype))
13889             return 1;
13890         }
13891       else
13892         {
13893           /* Must have been called from md_estimate_size_before_relax.  */
13894           if (symsec != sec)
13895             {
13896               fragp->fr_subtype =
13897                 RELAX_MIPS16_MARK_LONG_BRANCH (fragp->fr_subtype);
13898
13899               /* FIXME: We should support this, and let the linker
13900                  catch branches and loads that are out of range.  */
13901               as_bad_where (fragp->fr_file, fragp->fr_line,
13902                             _("unsupported PC relative reference to different section"));
13903
13904               return 1;
13905             }
13906           if (fragp != sym_frag && sym_frag->fr_address == 0)
13907             /* Assume non-extended on the first relaxation pass.
13908                The address we have calculated will be bogus if this is
13909                a forward branch to another frag, as the forward frag
13910                will have fr_address == 0.  */
13911             return 0;
13912         }
13913
13914       /* In this case, we know for sure that the symbol fragment is in
13915          the same section.  If the relax_marker of the symbol fragment
13916          differs from the relax_marker of this fragment, we have not
13917          yet adjusted the symbol fragment fr_address.  We want to add
13918          in STRETCH in order to get a better estimate of the address.
13919          This particularly matters because of the shift bits.  */
13920       if (stretch != 0
13921           && sym_frag->relax_marker != fragp->relax_marker)
13922         {
13923           fragS *f;
13924
13925           /* Adjust stretch for any alignment frag.  Note that if have
13926              been expanding the earlier code, the symbol may be
13927              defined in what appears to be an earlier frag.  FIXME:
13928              This doesn't handle the fr_subtype field, which specifies
13929              a maximum number of bytes to skip when doing an
13930              alignment.  */
13931           for (f = fragp; f != NULL && f != sym_frag; f = f->fr_next)
13932             {
13933               if (f->fr_type == rs_align || f->fr_type == rs_align_code)
13934                 {
13935                   if (stretch < 0)
13936                     stretch = - ((- stretch)
13937                                  & ~ ((1 << (int) f->fr_offset) - 1));
13938                   else
13939                     stretch &= ~ ((1 << (int) f->fr_offset) - 1);
13940                   if (stretch == 0)
13941                     break;
13942                 }
13943             }
13944           if (f != NULL)
13945             val += stretch;
13946         }
13947
13948       addr = fragp->fr_address + fragp->fr_fix;
13949
13950       /* The base address rules are complicated.  The base address of
13951          a branch is the following instruction.  The base address of a
13952          PC relative load or add is the instruction itself, but if it
13953          is in a delay slot (in which case it can not be extended) use
13954          the address of the instruction whose delay slot it is in.  */
13955       if (type == 'p' || type == 'q')
13956         {
13957           addr += 2;
13958
13959           /* If we are currently assuming that this frag should be
13960              extended, then, the current address is two bytes
13961              higher.  */
13962           if (RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
13963             addr += 2;
13964
13965           /* Ignore the low bit in the target, since it will be set
13966              for a text label.  */
13967           if ((val & 1) != 0)
13968             --val;
13969         }
13970       else if (RELAX_MIPS16_JAL_DSLOT (fragp->fr_subtype))
13971         addr -= 4;
13972       else if (RELAX_MIPS16_DSLOT (fragp->fr_subtype))
13973         addr -= 2;
13974
13975       val -= addr & ~ ((1 << op->shift) - 1);
13976
13977       /* Branch offsets have an implicit 0 in the lowest bit.  */
13978       if (type == 'p' || type == 'q')
13979         val /= 2;
13980
13981       /* If any of the shifted bits are set, we must use an extended
13982          opcode.  If the address depends on the size of this
13983          instruction, this can lead to a loop, so we arrange to always
13984          use an extended opcode.  We only check this when we are in
13985          the main relaxation loop, when SEC is NULL.  */
13986       if ((val & ((1 << op->shift) - 1)) != 0 && sec == NULL)
13987         {
13988           fragp->fr_subtype =
13989             RELAX_MIPS16_MARK_LONG_BRANCH (fragp->fr_subtype);
13990           return 1;
13991         }
13992
13993       /* If we are about to mark a frag as extended because the value
13994          is precisely maxtiny + 1, then there is a chance of an
13995          infinite loop as in the following code:
13996              la $4,foo
13997              .skip      1020
13998              .align     2
13999            foo:
14000          In this case when the la is extended, foo is 0x3fc bytes
14001          away, so the la can be shrunk, but then foo is 0x400 away, so
14002          the la must be extended.  To avoid this loop, we mark the
14003          frag as extended if it was small, and is about to become
14004          extended with a value of maxtiny + 1.  */
14005       if (val == ((maxtiny + 1) << op->shift)
14006           && ! RELAX_MIPS16_EXTENDED (fragp->fr_subtype)
14007           && sec == NULL)
14008         {
14009           fragp->fr_subtype =
14010             RELAX_MIPS16_MARK_LONG_BRANCH (fragp->fr_subtype);
14011           return 1;
14012         }
14013     }
14014   else if (symsec != absolute_section && sec != NULL)
14015     as_bad_where (fragp->fr_file, fragp->fr_line, _("unsupported relocation"));
14016
14017   if ((val & ((1 << op->shift) - 1)) != 0
14018       || val < (mintiny << op->shift)
14019       || val > (maxtiny << op->shift))
14020     return 1;
14021   else
14022     return 0;
14023 }
14024
14025 /* Compute the length of a branch sequence, and adjust the
14026    RELAX_BRANCH_TOOFAR bit accordingly.  If FRAGP is NULL, the
14027    worst-case length is computed, with UPDATE being used to indicate
14028    whether an unconditional (-1), branch-likely (+1) or regular (0)
14029    branch is to be computed.  */
14030 static int
14031 relaxed_branch_length (fragS *fragp, asection *sec, int update)
14032 {
14033   bfd_boolean toofar;
14034   int length;
14035
14036   if (fragp
14037       && S_IS_DEFINED (fragp->fr_symbol)
14038       && sec == S_GET_SEGMENT (fragp->fr_symbol))
14039     {
14040       addressT addr;
14041       offsetT val;
14042
14043       val = S_GET_VALUE (fragp->fr_symbol) + fragp->fr_offset;
14044
14045       addr = fragp->fr_address + fragp->fr_fix + 4;
14046
14047       val -= addr;
14048
14049       toofar = val < - (0x8000 << 2) || val >= (0x8000 << 2);
14050     }
14051   else if (fragp)
14052     /* If the symbol is not defined or it's in a different segment,
14053        assume the user knows what's going on and emit a short
14054        branch.  */
14055     toofar = FALSE;
14056   else
14057     toofar = TRUE;
14058
14059   if (fragp && update && toofar != RELAX_BRANCH_TOOFAR (fragp->fr_subtype))
14060     fragp->fr_subtype
14061       = RELAX_BRANCH_ENCODE (RELAX_BRANCH_UNCOND (fragp->fr_subtype),
14062                              RELAX_BRANCH_LIKELY (fragp->fr_subtype),
14063                              RELAX_BRANCH_LINK (fragp->fr_subtype),
14064                              toofar);
14065
14066   length = 4;
14067   if (toofar)
14068     {
14069       if (fragp ? RELAX_BRANCH_LIKELY (fragp->fr_subtype) : (update > 0))
14070         length += 8;
14071
14072       if (mips_pic != NO_PIC)
14073         {
14074           /* Additional space for PIC loading of target address.  */
14075           length += 8;
14076           if (mips_opts.isa == ISA_MIPS1)
14077             /* Additional space for $at-stabilizing nop.  */
14078             length += 4;
14079         }
14080
14081       /* If branch is conditional.  */
14082       if (fragp ? !RELAX_BRANCH_UNCOND (fragp->fr_subtype) : (update >= 0))
14083         length += 8;
14084     }
14085
14086   return length;
14087 }
14088
14089 /* Estimate the size of a frag before relaxing.  Unless this is the
14090    mips16, we are not really relaxing here, and the final size is
14091    encoded in the subtype information.  For the mips16, we have to
14092    decide whether we are using an extended opcode or not.  */
14093
14094 int
14095 md_estimate_size_before_relax (fragS *fragp, asection *segtype)
14096 {
14097   int change;
14098
14099   if (RELAX_BRANCH_P (fragp->fr_subtype))
14100     {
14101
14102       fragp->fr_var = relaxed_branch_length (fragp, segtype, FALSE);
14103
14104       return fragp->fr_var;
14105     }
14106
14107   if (RELAX_MIPS16_P (fragp->fr_subtype))
14108     /* We don't want to modify the EXTENDED bit here; it might get us
14109        into infinite loops.  We change it only in mips_relax_frag().  */
14110     return (RELAX_MIPS16_EXTENDED (fragp->fr_subtype) ? 4 : 2);
14111
14112   if (mips_pic == NO_PIC)
14113     change = nopic_need_relax (fragp->fr_symbol, 0);
14114   else if (mips_pic == SVR4_PIC)
14115     change = pic_need_relax (fragp->fr_symbol, segtype);
14116   else if (mips_pic == VXWORKS_PIC)
14117     /* For vxworks, GOT16 relocations never have a corresponding LO16.  */
14118     change = 0;
14119   else
14120     abort ();
14121
14122   if (change)
14123     {
14124       fragp->fr_subtype |= RELAX_USE_SECOND;
14125       return -RELAX_FIRST (fragp->fr_subtype);
14126     }
14127   else
14128     return -RELAX_SECOND (fragp->fr_subtype);
14129 }
14130
14131 /* This is called to see whether a reloc against a defined symbol
14132    should be converted into a reloc against a section.  */
14133
14134 int
14135 mips_fix_adjustable (fixS *fixp)
14136 {
14137   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
14138       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
14139     return 0;
14140
14141   if (fixp->fx_addsy == NULL)
14142     return 1;
14143
14144   /* If symbol SYM is in a mergeable section, relocations of the form
14145      SYM + 0 can usually be made section-relative.  The mergeable data
14146      is then identified by the section offset rather than by the symbol.
14147
14148      However, if we're generating REL LO16 relocations, the offset is split
14149      between the LO16 and parterning high part relocation.  The linker will
14150      need to recalculate the complete offset in order to correctly identify
14151      the merge data.
14152
14153      The linker has traditionally not looked for the parterning high part
14154      relocation, and has thus allowed orphaned R_MIPS_LO16 relocations to be
14155      placed anywhere.  Rather than break backwards compatibility by changing
14156      this, it seems better not to force the issue, and instead keep the
14157      original symbol.  This will work with either linker behavior.  */
14158   if ((lo16_reloc_p (fixp->fx_r_type)
14159        || reloc_needs_lo_p (fixp->fx_r_type))
14160       && HAVE_IN_PLACE_ADDENDS
14161       && (S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_MERGE) != 0)
14162     return 0;
14163
14164   /* There is no place to store an in-place offset for JALR relocations.  */
14165   if (fixp->fx_r_type == BFD_RELOC_MIPS_JALR && HAVE_IN_PLACE_ADDENDS)
14166     return 0;
14167
14168 #ifdef OBJ_ELF
14169   /* R_MIPS16_26 relocations against non-MIPS16 functions might resolve
14170      to a floating-point stub.  The same is true for non-R_MIPS16_26
14171      relocations against MIPS16 functions; in this case, the stub becomes
14172      the function's canonical address.
14173
14174      Floating-point stubs are stored in unique .mips16.call.* or
14175      .mips16.fn.* sections.  If a stub T for function F is in section S,
14176      the first relocation in section S must be against F; this is how the
14177      linker determines the target function.  All relocations that might
14178      resolve to T must also be against F.  We therefore have the following
14179      restrictions, which are given in an intentionally-redundant way:
14180
14181        1. We cannot reduce R_MIPS16_26 relocations against non-MIPS16
14182           symbols.
14183
14184        2. We cannot reduce a stub's relocations against non-MIPS16 symbols
14185           if that stub might be used.
14186
14187        3. We cannot reduce non-R_MIPS16_26 relocations against MIPS16
14188           symbols.
14189
14190        4. We cannot reduce a stub's relocations against MIPS16 symbols if
14191           that stub might be used.
14192
14193      There is a further restriction:
14194
14195        5. We cannot reduce R_MIPS16_26 relocations against MIPS16 symbols
14196           on targets with in-place addends; the relocation field cannot
14197           encode the low bit.
14198
14199      For simplicity, we deal with (3)-(5) by not reducing _any_ relocation
14200      against a MIPS16 symbol.
14201
14202      We deal with (1)-(2) by saying that, if there's a R_MIPS16_26
14203      relocation against some symbol R, no relocation against R may be
14204      reduced.  (Note that this deals with (2) as well as (1) because
14205      relocations against global symbols will never be reduced on ELF
14206      targets.)  This approach is a little simpler than trying to detect
14207      stub sections, and gives the "all or nothing" per-symbol consistency
14208      that we have for MIPS16 symbols.  */
14209   if (IS_ELF
14210       && fixp->fx_subsy == NULL
14211       && (ELF_ST_IS_MIPS16 (S_GET_OTHER (fixp->fx_addsy))
14212           || *symbol_get_tc (fixp->fx_addsy)))
14213     return 0;
14214 #endif
14215
14216   return 1;
14217 }
14218
14219 /* Translate internal representation of relocation info to BFD target
14220    format.  */
14221
14222 arelent **
14223 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
14224 {
14225   static arelent *retval[4];
14226   arelent *reloc;
14227   bfd_reloc_code_real_type code;
14228
14229   memset (retval, 0, sizeof(retval));
14230   reloc = retval[0] = (arelent *) xcalloc (1, sizeof (arelent));
14231   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
14232   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
14233   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
14234
14235   if (fixp->fx_pcrel)
14236     {
14237       gas_assert (fixp->fx_r_type == BFD_RELOC_16_PCREL_S2);
14238
14239       /* At this point, fx_addnumber is "symbol offset - pcrel address".
14240          Relocations want only the symbol offset.  */
14241       reloc->addend = fixp->fx_addnumber + reloc->address;
14242       if (!IS_ELF)
14243         {
14244           /* A gruesome hack which is a result of the gruesome gas
14245              reloc handling.  What's worse, for COFF (as opposed to
14246              ECOFF), we might need yet another copy of reloc->address.
14247              See bfd_install_relocation.  */
14248           reloc->addend += reloc->address;
14249         }
14250     }
14251   else
14252     reloc->addend = fixp->fx_addnumber;
14253
14254   /* Since the old MIPS ELF ABI uses Rel instead of Rela, encode the vtable
14255      entry to be used in the relocation's section offset.  */
14256   if (! HAVE_NEWABI && fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
14257     {
14258       reloc->address = reloc->addend;
14259       reloc->addend = 0;
14260     }
14261
14262   code = fixp->fx_r_type;
14263
14264   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
14265   if (reloc->howto == NULL)
14266     {
14267       as_bad_where (fixp->fx_file, fixp->fx_line,
14268                     _("Can not represent %s relocation in this object file format"),
14269                     bfd_get_reloc_code_name (code));
14270       retval[0] = NULL;
14271     }
14272
14273   return retval;
14274 }
14275
14276 /* Relax a machine dependent frag.  This returns the amount by which
14277    the current size of the frag should change.  */
14278
14279 int
14280 mips_relax_frag (asection *sec, fragS *fragp, long stretch)
14281 {
14282   if (RELAX_BRANCH_P (fragp->fr_subtype))
14283     {
14284       offsetT old_var = fragp->fr_var;
14285
14286       fragp->fr_var = relaxed_branch_length (fragp, sec, TRUE);
14287
14288       return fragp->fr_var - old_var;
14289     }
14290
14291   if (! RELAX_MIPS16_P (fragp->fr_subtype))
14292     return 0;
14293
14294   if (mips16_extended_frag (fragp, NULL, stretch))
14295     {
14296       if (RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
14297         return 0;
14298       fragp->fr_subtype = RELAX_MIPS16_MARK_EXTENDED (fragp->fr_subtype);
14299       return 2;
14300     }
14301   else
14302     {
14303       if (! RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
14304         return 0;
14305       fragp->fr_subtype = RELAX_MIPS16_CLEAR_EXTENDED (fragp->fr_subtype);
14306       return -2;
14307     }
14308
14309   return 0;
14310 }
14311
14312 /* Convert a machine dependent frag.  */
14313
14314 void
14315 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT asec, fragS *fragp)
14316 {
14317   if (RELAX_BRANCH_P (fragp->fr_subtype))
14318     {
14319       bfd_byte *buf;
14320       unsigned long insn;
14321       expressionS exp;
14322       fixS *fixp;
14323
14324       buf = (bfd_byte *)fragp->fr_literal + fragp->fr_fix;
14325
14326       if (target_big_endian)
14327         insn = bfd_getb32 (buf);
14328       else
14329         insn = bfd_getl32 (buf);
14330
14331       if (!RELAX_BRANCH_TOOFAR (fragp->fr_subtype))
14332         {
14333           /* We generate a fixup instead of applying it right now
14334              because, if there are linker relaxations, we're going to
14335              need the relocations.  */
14336           exp.X_op = O_symbol;
14337           exp.X_add_symbol = fragp->fr_symbol;
14338           exp.X_add_number = fragp->fr_offset;
14339
14340           fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
14341                               4, &exp, TRUE, BFD_RELOC_16_PCREL_S2);
14342           fixp->fx_file = fragp->fr_file;
14343           fixp->fx_line = fragp->fr_line;
14344
14345           md_number_to_chars ((char *) buf, insn, 4);
14346           buf += 4;
14347         }
14348       else
14349         {
14350           int i;
14351
14352           as_warn_where (fragp->fr_file, fragp->fr_line,
14353                          _("relaxed out-of-range branch into a jump"));
14354
14355           if (RELAX_BRANCH_UNCOND (fragp->fr_subtype))
14356             goto uncond;
14357
14358           if (!RELAX_BRANCH_LIKELY (fragp->fr_subtype))
14359             {
14360               /* Reverse the branch.  */
14361               switch ((insn >> 28) & 0xf)
14362                 {
14363                 case 4:
14364                   /* bc[0-3][tf]l? and bc1any[24][ft] instructions can
14365                      have the condition reversed by tweaking a single
14366                      bit, and their opcodes all have 0x4???????.  */
14367                   gas_assert ((insn & 0xf1000000) == 0x41000000);
14368                   insn ^= 0x00010000;
14369                   break;
14370
14371                 case 0:
14372                   /* bltz       0x04000000      bgez    0x04010000
14373                      bltzal     0x04100000      bgezal  0x04110000  */
14374                   gas_assert ((insn & 0xfc0e0000) == 0x04000000);
14375                   insn ^= 0x00010000;
14376                   break;
14377
14378                 case 1:
14379                   /* beq        0x10000000      bne     0x14000000
14380                      blez       0x18000000      bgtz    0x1c000000  */
14381                   insn ^= 0x04000000;
14382                   break;
14383
14384                 default:
14385                   abort ();
14386                 }
14387             }
14388
14389           if (RELAX_BRANCH_LINK (fragp->fr_subtype))
14390             {
14391               /* Clear the and-link bit.  */
14392               gas_assert ((insn & 0xfc1c0000) == 0x04100000);
14393
14394               /* bltzal         0x04100000      bgezal  0x04110000
14395                  bltzall        0x04120000      bgezall 0x04130000  */
14396               insn &= ~0x00100000;
14397             }
14398
14399           /* Branch over the branch (if the branch was likely) or the
14400              full jump (not likely case).  Compute the offset from the
14401              current instruction to branch to.  */
14402           if (RELAX_BRANCH_LIKELY (fragp->fr_subtype))
14403             i = 16;
14404           else
14405             {
14406               /* How many bytes in instructions we've already emitted?  */
14407               i = buf - (bfd_byte *)fragp->fr_literal - fragp->fr_fix;
14408               /* How many bytes in instructions from here to the end?  */
14409               i = fragp->fr_var - i;
14410             }
14411           /* Convert to instruction count.  */
14412           i >>= 2;
14413           /* Branch counts from the next instruction.  */
14414           i--;
14415           insn |= i;
14416           /* Branch over the jump.  */
14417           md_number_to_chars ((char *) buf, insn, 4);
14418           buf += 4;
14419
14420           /* nop */
14421           md_number_to_chars ((char *) buf, 0, 4);
14422           buf += 4;
14423
14424           if (RELAX_BRANCH_LIKELY (fragp->fr_subtype))
14425             {
14426               /* beql $0, $0, 2f */
14427               insn = 0x50000000;
14428               /* Compute the PC offset from the current instruction to
14429                  the end of the variable frag.  */
14430               /* How many bytes in instructions we've already emitted?  */
14431               i = buf - (bfd_byte *)fragp->fr_literal - fragp->fr_fix;
14432               /* How many bytes in instructions from here to the end?  */
14433               i = fragp->fr_var - i;
14434               /* Convert to instruction count.  */
14435               i >>= 2;
14436               /* Don't decrement i, because we want to branch over the
14437                  delay slot.  */
14438
14439               insn |= i;
14440               md_number_to_chars ((char *) buf, insn, 4);
14441               buf += 4;
14442
14443               md_number_to_chars ((char *) buf, 0, 4);
14444               buf += 4;
14445             }
14446
14447         uncond:
14448           if (mips_pic == NO_PIC)
14449             {
14450               /* j or jal.  */
14451               insn = (RELAX_BRANCH_LINK (fragp->fr_subtype)
14452                       ? 0x0c000000 : 0x08000000);
14453               exp.X_op = O_symbol;
14454               exp.X_add_symbol = fragp->fr_symbol;
14455               exp.X_add_number = fragp->fr_offset;
14456
14457               fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
14458                                   4, &exp, FALSE, BFD_RELOC_MIPS_JMP);
14459               fixp->fx_file = fragp->fr_file;
14460               fixp->fx_line = fragp->fr_line;
14461
14462               md_number_to_chars ((char *) buf, insn, 4);
14463               buf += 4;
14464             }
14465           else
14466             {
14467               /* lw/ld $at, <sym>($gp)  R_MIPS_GOT16 */
14468               insn = HAVE_64BIT_ADDRESSES ? 0xdf810000 : 0x8f810000;
14469               exp.X_op = O_symbol;
14470               exp.X_add_symbol = fragp->fr_symbol;
14471               exp.X_add_number = fragp->fr_offset;
14472
14473               if (fragp->fr_offset)
14474                 {
14475                   exp.X_add_symbol = make_expr_symbol (&exp);
14476                   exp.X_add_number = 0;
14477                 }
14478
14479               fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
14480                                   4, &exp, FALSE, BFD_RELOC_MIPS_GOT16);
14481               fixp->fx_file = fragp->fr_file;
14482               fixp->fx_line = fragp->fr_line;
14483
14484               md_number_to_chars ((char *) buf, insn, 4);
14485               buf += 4;
14486
14487               if (mips_opts.isa == ISA_MIPS1)
14488                 {
14489                   /* nop */
14490                   md_number_to_chars ((char *) buf, 0, 4);
14491                   buf += 4;
14492                 }
14493
14494               /* d/addiu $at, $at, <sym>  R_MIPS_LO16 */
14495               insn = HAVE_64BIT_ADDRESSES ? 0x64210000 : 0x24210000;
14496
14497               fixp = fix_new_exp (fragp, buf - (bfd_byte *)fragp->fr_literal,
14498                                   4, &exp, FALSE, BFD_RELOC_LO16);
14499               fixp->fx_file = fragp->fr_file;
14500               fixp->fx_line = fragp->fr_line;
14501
14502               md_number_to_chars ((char *) buf, insn, 4);
14503               buf += 4;
14504
14505               /* j(al)r $at.  */
14506               if (RELAX_BRANCH_LINK (fragp->fr_subtype))
14507                 insn = 0x0020f809;
14508               else
14509                 insn = 0x00200008;
14510
14511               md_number_to_chars ((char *) buf, insn, 4);
14512               buf += 4;
14513             }
14514         }
14515
14516       gas_assert (buf == (bfd_byte *)fragp->fr_literal
14517               + fragp->fr_fix + fragp->fr_var);
14518
14519       fragp->fr_fix += fragp->fr_var;
14520
14521       return;
14522     }
14523
14524   if (RELAX_MIPS16_P (fragp->fr_subtype))
14525     {
14526       int type;
14527       const struct mips16_immed_operand *op;
14528       bfd_boolean small, ext;
14529       offsetT val;
14530       bfd_byte *buf;
14531       unsigned long insn;
14532       bfd_boolean use_extend;
14533       unsigned short extend;
14534
14535       type = RELAX_MIPS16_TYPE (fragp->fr_subtype);
14536       op = mips16_immed_operands;
14537       while (op->type != type)
14538         ++op;
14539
14540       if (RELAX_MIPS16_EXTENDED (fragp->fr_subtype))
14541         {
14542           small = FALSE;
14543           ext = TRUE;
14544         }
14545       else
14546         {
14547           small = TRUE;
14548           ext = FALSE;
14549         }
14550
14551       val = resolve_symbol_value (fragp->fr_symbol);
14552       if (op->pcrel)
14553         {
14554           addressT addr;
14555
14556           addr = fragp->fr_address + fragp->fr_fix;
14557
14558           /* The rules for the base address of a PC relative reloc are
14559              complicated; see mips16_extended_frag.  */
14560           if (type == 'p' || type == 'q')
14561             {
14562               addr += 2;
14563               if (ext)
14564                 addr += 2;
14565               /* Ignore the low bit in the target, since it will be
14566                  set for a text label.  */
14567               if ((val & 1) != 0)
14568                 --val;
14569             }
14570           else if (RELAX_MIPS16_JAL_DSLOT (fragp->fr_subtype))
14571             addr -= 4;
14572           else if (RELAX_MIPS16_DSLOT (fragp->fr_subtype))
14573             addr -= 2;
14574
14575           addr &= ~ (addressT) ((1 << op->shift) - 1);
14576           val -= addr;
14577
14578           /* Make sure the section winds up with the alignment we have
14579              assumed.  */
14580           if (op->shift > 0)
14581             record_alignment (asec, op->shift);
14582         }
14583
14584       if (ext
14585           && (RELAX_MIPS16_JAL_DSLOT (fragp->fr_subtype)
14586               || RELAX_MIPS16_DSLOT (fragp->fr_subtype)))
14587         as_warn_where (fragp->fr_file, fragp->fr_line,
14588                        _("extended instruction in delay slot"));
14589
14590       buf = (bfd_byte *) (fragp->fr_literal + fragp->fr_fix);
14591
14592       if (target_big_endian)
14593         insn = bfd_getb16 (buf);
14594       else
14595         insn = bfd_getl16 (buf);
14596
14597       mips16_immed (fragp->fr_file, fragp->fr_line, type, val,
14598                     RELAX_MIPS16_USER_EXT (fragp->fr_subtype),
14599                     small, ext, &insn, &use_extend, &extend);
14600
14601       if (use_extend)
14602         {
14603           md_number_to_chars ((char *) buf, 0xf000 | extend, 2);
14604           fragp->fr_fix += 2;
14605           buf += 2;
14606         }
14607
14608       md_number_to_chars ((char *) buf, insn, 2);
14609       fragp->fr_fix += 2;
14610       buf += 2;
14611     }
14612   else
14613     {
14614       int first, second;
14615       fixS *fixp;
14616
14617       first = RELAX_FIRST (fragp->fr_subtype);
14618       second = RELAX_SECOND (fragp->fr_subtype);
14619       fixp = (fixS *) fragp->fr_opcode;
14620
14621       /* Possibly emit a warning if we've chosen the longer option.  */
14622       if (((fragp->fr_subtype & RELAX_USE_SECOND) != 0)
14623           == ((fragp->fr_subtype & RELAX_SECOND_LONGER) != 0))
14624         {
14625           const char *msg = macro_warning (fragp->fr_subtype);
14626           if (msg != 0)
14627             as_warn_where (fragp->fr_file, fragp->fr_line, "%s", msg);
14628         }
14629
14630       /* Go through all the fixups for the first sequence.  Disable them
14631          (by marking them as done) if we're going to use the second
14632          sequence instead.  */
14633       while (fixp
14634              && fixp->fx_frag == fragp
14635              && fixp->fx_where < fragp->fr_fix - second)
14636         {
14637           if (fragp->fr_subtype & RELAX_USE_SECOND)
14638             fixp->fx_done = 1;
14639           fixp = fixp->fx_next;
14640         }
14641
14642       /* Go through the fixups for the second sequence.  Disable them if
14643          we're going to use the first sequence, otherwise adjust their
14644          addresses to account for the relaxation.  */
14645       while (fixp && fixp->fx_frag == fragp)
14646         {
14647           if (fragp->fr_subtype & RELAX_USE_SECOND)
14648             fixp->fx_where -= first;
14649           else
14650             fixp->fx_done = 1;
14651           fixp = fixp->fx_next;
14652         }
14653
14654       /* Now modify the frag contents.  */
14655       if (fragp->fr_subtype & RELAX_USE_SECOND)
14656         {
14657           char *start;
14658
14659           start = fragp->fr_literal + fragp->fr_fix - first - second;
14660           memmove (start, start + first, second);
14661           fragp->fr_fix -= first;
14662         }
14663       else
14664         fragp->fr_fix -= second;
14665     }
14666 }
14667
14668 #ifdef OBJ_ELF
14669
14670 /* This function is called after the relocs have been generated.
14671    We've been storing mips16 text labels as odd.  Here we convert them
14672    back to even for the convenience of the debugger.  */
14673
14674 void
14675 mips_frob_file_after_relocs (void)
14676 {
14677   asymbol **syms;
14678   unsigned int count, i;
14679
14680   if (!IS_ELF)
14681     return;
14682
14683   syms = bfd_get_outsymbols (stdoutput);
14684   count = bfd_get_symcount (stdoutput);
14685   for (i = 0; i < count; i++, syms++)
14686     {
14687       if (ELF_ST_IS_MIPS16 (elf_symbol (*syms)->internal_elf_sym.st_other)
14688           && ((*syms)->value & 1) != 0)
14689         {
14690           (*syms)->value &= ~1;
14691           /* If the symbol has an odd size, it was probably computed
14692              incorrectly, so adjust that as well.  */
14693           if ((elf_symbol (*syms)->internal_elf_sym.st_size & 1) != 0)
14694             ++elf_symbol (*syms)->internal_elf_sym.st_size;
14695         }
14696     }
14697 }
14698
14699 #endif
14700
14701 /* This function is called whenever a label is defined.  It is used
14702    when handling branch delays; if a branch has a label, we assume we
14703    can not move it.  */
14704
14705 void
14706 mips_define_label (symbolS *sym)
14707 {
14708   segment_info_type *si = seg_info (now_seg);
14709   struct insn_label_list *l;
14710
14711   if (free_insn_labels == NULL)
14712     l = (struct insn_label_list *) xmalloc (sizeof *l);
14713   else
14714     {
14715       l = free_insn_labels;
14716       free_insn_labels = l->next;
14717     }
14718
14719   l->label = sym;
14720   l->next = si->label_list;
14721   si->label_list = l;
14722
14723 #ifdef OBJ_ELF
14724   dwarf2_emit_label (sym);
14725 #endif
14726 }
14727 \f
14728 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
14729
14730 /* Some special processing for a MIPS ELF file.  */
14731
14732 void
14733 mips_elf_final_processing (void)
14734 {
14735   /* Write out the register information.  */
14736   if (mips_abi != N64_ABI)
14737     {
14738       Elf32_RegInfo s;
14739
14740       s.ri_gprmask = mips_gprmask;
14741       s.ri_cprmask[0] = mips_cprmask[0];
14742       s.ri_cprmask[1] = mips_cprmask[1];
14743       s.ri_cprmask[2] = mips_cprmask[2];
14744       s.ri_cprmask[3] = mips_cprmask[3];
14745       /* The gp_value field is set by the MIPS ELF backend.  */
14746
14747       bfd_mips_elf32_swap_reginfo_out (stdoutput, &s,
14748                                        ((Elf32_External_RegInfo *)
14749                                         mips_regmask_frag));
14750     }
14751   else
14752     {
14753       Elf64_Internal_RegInfo s;
14754
14755       s.ri_gprmask = mips_gprmask;
14756       s.ri_pad = 0;
14757       s.ri_cprmask[0] = mips_cprmask[0];
14758       s.ri_cprmask[1] = mips_cprmask[1];
14759       s.ri_cprmask[2] = mips_cprmask[2];
14760       s.ri_cprmask[3] = mips_cprmask[3];
14761       /* The gp_value field is set by the MIPS ELF backend.  */
14762
14763       bfd_mips_elf64_swap_reginfo_out (stdoutput, &s,
14764                                        ((Elf64_External_RegInfo *)
14765                                         mips_regmask_frag));
14766     }
14767
14768   /* Set the MIPS ELF flag bits.  FIXME: There should probably be some
14769      sort of BFD interface for this.  */
14770   if (mips_any_noreorder)
14771     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_NOREORDER;
14772   if (mips_pic != NO_PIC)
14773     {
14774     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_PIC;
14775       elf_elfheader (stdoutput)->e_flags |= EF_MIPS_CPIC;
14776     }
14777   if (mips_abicalls)
14778     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_CPIC;
14779
14780   /* Set MIPS ELF flags for ASEs.  */
14781   /* We may need to define a new flag for DSP ASE, and set this flag when
14782      file_ase_dsp is true.  */
14783   /* Same for DSP R2.  */
14784   /* We may need to define a new flag for MT ASE, and set this flag when
14785      file_ase_mt is true.  */
14786   if (file_ase_mips16)
14787     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_ARCH_ASE_M16;
14788 #if 0 /* XXX FIXME */
14789   if (file_ase_mips3d)
14790     elf_elfheader (stdoutput)->e_flags |= ???;
14791 #endif
14792   if (file_ase_mdmx)
14793     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_ARCH_ASE_MDMX;
14794
14795   /* Set the MIPS ELF ABI flags.  */
14796   if (mips_abi == O32_ABI && USE_E_MIPS_ABI_O32)
14797     elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_O32;
14798   else if (mips_abi == O64_ABI)
14799     elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_O64;
14800   else if (mips_abi == EABI_ABI)
14801     {
14802       if (!file_mips_gp32)
14803         elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_EABI64;
14804       else
14805         elf_elfheader (stdoutput)->e_flags |= E_MIPS_ABI_EABI32;
14806     }
14807   else if (mips_abi == N32_ABI)
14808     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_ABI2;
14809
14810   /* Nothing to do for N64_ABI.  */
14811
14812   if (mips_32bitmode)
14813     elf_elfheader (stdoutput)->e_flags |= EF_MIPS_32BITMODE;
14814
14815 #if 0 /* XXX FIXME */
14816   /* 32 bit code with 64 bit FP registers.  */
14817   if (!file_mips_fp32 && ABI_NEEDS_32BIT_REGS (mips_abi))
14818     elf_elfheader (stdoutput)->e_flags |= ???;
14819 #endif
14820 }
14821
14822 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */
14823 \f
14824 typedef struct proc {
14825   symbolS *func_sym;
14826   symbolS *func_end_sym;
14827   unsigned long reg_mask;
14828   unsigned long reg_offset;
14829   unsigned long fpreg_mask;
14830   unsigned long fpreg_offset;
14831   unsigned long frame_offset;
14832   unsigned long frame_reg;
14833   unsigned long pc_reg;
14834 } procS;
14835
14836 static procS cur_proc;
14837 static procS *cur_proc_ptr;
14838 static int numprocs;
14839
14840 /* Implement NOP_OPCODE.  We encode a MIPS16 nop as "1" and a normal
14841    nop as "0".  */
14842
14843 char
14844 mips_nop_opcode (void)
14845 {
14846   return seg_info (now_seg)->tc_segment_info_data.mips16;
14847 }
14848
14849 /* Fill in an rs_align_code fragment.  This only needs to do something
14850    for MIPS16 code, where 0 is not a nop.  */
14851
14852 void
14853 mips_handle_align (fragS *fragp)
14854 {
14855   char *p;
14856   int bytes, size, excess;
14857   valueT opcode;
14858
14859   if (fragp->fr_type != rs_align_code)
14860     return;
14861
14862   p = fragp->fr_literal + fragp->fr_fix;
14863   if (*p)
14864     {
14865       opcode = mips16_nop_insn.insn_opcode;
14866       size = 2;
14867     }
14868   else
14869     {
14870       opcode = nop_insn.insn_opcode;
14871       size = 4;
14872     }
14873
14874   bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
14875   excess = bytes % size;
14876   if (excess != 0)
14877     {
14878       /* If we're not inserting a whole number of instructions,
14879          pad the end of the fixed part of the frag with zeros.  */
14880       memset (p, 0, excess);
14881       p += excess;
14882       fragp->fr_fix += excess;
14883     }
14884
14885   md_number_to_chars (p, opcode, size);
14886   fragp->fr_var = size;
14887 }
14888
14889 static void
14890 md_obj_begin (void)
14891 {
14892 }
14893
14894 static void
14895 md_obj_end (void)
14896 {
14897   /* Check for premature end, nesting errors, etc.  */
14898   if (cur_proc_ptr)
14899     as_warn (_("missing .end at end of assembly"));
14900 }
14901
14902 static long
14903 get_number (void)
14904 {
14905   int negative = 0;
14906   long val = 0;
14907
14908   if (*input_line_pointer == '-')
14909     {
14910       ++input_line_pointer;
14911       negative = 1;
14912     }
14913   if (!ISDIGIT (*input_line_pointer))
14914     as_bad (_("expected simple number"));
14915   if (input_line_pointer[0] == '0')
14916     {
14917       if (input_line_pointer[1] == 'x')
14918         {
14919           input_line_pointer += 2;
14920           while (ISXDIGIT (*input_line_pointer))
14921             {
14922               val <<= 4;
14923               val |= hex_value (*input_line_pointer++);
14924             }
14925           return negative ? -val : val;
14926         }
14927       else
14928         {
14929           ++input_line_pointer;
14930           while (ISDIGIT (*input_line_pointer))
14931             {
14932               val <<= 3;
14933               val |= *input_line_pointer++ - '0';
14934             }
14935           return negative ? -val : val;
14936         }
14937     }
14938   if (!ISDIGIT (*input_line_pointer))
14939     {
14940       printf (_(" *input_line_pointer == '%c' 0x%02x\n"),
14941               *input_line_pointer, *input_line_pointer);
14942       as_warn (_("invalid number"));
14943       return -1;
14944     }
14945   while (ISDIGIT (*input_line_pointer))
14946     {
14947       val *= 10;
14948       val += *input_line_pointer++ - '0';
14949     }
14950   return negative ? -val : val;
14951 }
14952
14953 /* The .file directive; just like the usual .file directive, but there
14954    is an initial number which is the ECOFF file index.  In the non-ECOFF
14955    case .file implies DWARF-2.  */
14956
14957 static void
14958 s_mips_file (int x ATTRIBUTE_UNUSED)
14959 {
14960   static int first_file_directive = 0;
14961
14962   if (ECOFF_DEBUGGING)
14963     {
14964       get_number ();
14965       s_app_file (0);
14966     }
14967   else
14968     {
14969       char *filename;
14970
14971       filename = dwarf2_directive_file (0);
14972
14973       /* Versions of GCC up to 3.1 start files with a ".file"
14974          directive even for stabs output.  Make sure that this
14975          ".file" is handled.  Note that you need a version of GCC
14976          after 3.1 in order to support DWARF-2 on MIPS.  */
14977       if (filename != NULL && ! first_file_directive)
14978         {
14979           (void) new_logical_line (filename, -1);
14980           s_app_file_string (filename, 0);
14981         }
14982       first_file_directive = 1;
14983     }
14984 }
14985
14986 /* The .loc directive, implying DWARF-2.  */
14987
14988 static void
14989 s_mips_loc (int x ATTRIBUTE_UNUSED)
14990 {
14991   if (!ECOFF_DEBUGGING)
14992     dwarf2_directive_loc (0);
14993 }
14994
14995 /* The .end directive.  */
14996
14997 static void
14998 s_mips_end (int x ATTRIBUTE_UNUSED)
14999 {
15000   symbolS *p;
15001
15002   /* Following functions need their own .frame and .cprestore directives.  */
15003   mips_frame_reg_valid = 0;
15004   mips_cprestore_valid = 0;
15005
15006   if (!is_end_of_line[(unsigned char) *input_line_pointer])
15007     {
15008       p = get_symbol ();
15009       demand_empty_rest_of_line ();
15010     }
15011   else
15012     p = NULL;
15013
15014   if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) == 0)
15015     as_warn (_(".end not in text section"));
15016
15017   if (!cur_proc_ptr)
15018     {
15019       as_warn (_(".end directive without a preceding .ent directive."));
15020       demand_empty_rest_of_line ();
15021       return;
15022     }
15023
15024   if (p != NULL)
15025     {
15026       gas_assert (S_GET_NAME (p));
15027       if (strcmp (S_GET_NAME (p), S_GET_NAME (cur_proc_ptr->func_sym)))
15028         as_warn (_(".end symbol does not match .ent symbol."));
15029
15030       if (debug_type == DEBUG_STABS)
15031         stabs_generate_asm_endfunc (S_GET_NAME (p),
15032                                     S_GET_NAME (p));
15033     }
15034   else
15035     as_warn (_(".end directive missing or unknown symbol"));
15036
15037 #ifdef OBJ_ELF
15038   /* Create an expression to calculate the size of the function.  */
15039   if (p && cur_proc_ptr)
15040     {
15041       OBJ_SYMFIELD_TYPE *obj = symbol_get_obj (p);
15042       expressionS *exp = xmalloc (sizeof (expressionS));
15043
15044       obj->size = exp;
15045       exp->X_op = O_subtract;
15046       exp->X_add_symbol = symbol_temp_new_now ();
15047       exp->X_op_symbol = p;
15048       exp->X_add_number = 0;
15049
15050       cur_proc_ptr->func_end_sym = exp->X_add_symbol;
15051     }
15052
15053   /* Generate a .pdr section.  */
15054   if (IS_ELF && !ECOFF_DEBUGGING && mips_flag_pdr)
15055     {
15056       segT saved_seg = now_seg;
15057       subsegT saved_subseg = now_subseg;
15058       expressionS exp;
15059       char *fragp;
15060
15061 #ifdef md_flush_pending_output
15062       md_flush_pending_output ();
15063 #endif
15064
15065       gas_assert (pdr_seg);
15066       subseg_set (pdr_seg, 0);
15067
15068       /* Write the symbol.  */
15069       exp.X_op = O_symbol;
15070       exp.X_add_symbol = p;
15071       exp.X_add_number = 0;
15072       emit_expr (&exp, 4);
15073
15074       fragp = frag_more (7 * 4);
15075
15076       md_number_to_chars (fragp, cur_proc_ptr->reg_mask, 4);
15077       md_number_to_chars (fragp + 4, cur_proc_ptr->reg_offset, 4);
15078       md_number_to_chars (fragp + 8, cur_proc_ptr->fpreg_mask, 4);
15079       md_number_to_chars (fragp + 12, cur_proc_ptr->fpreg_offset, 4);
15080       md_number_to_chars (fragp + 16, cur_proc_ptr->frame_offset, 4);
15081       md_number_to_chars (fragp + 20, cur_proc_ptr->frame_reg, 4);
15082       md_number_to_chars (fragp + 24, cur_proc_ptr->pc_reg, 4);
15083
15084       subseg_set (saved_seg, saved_subseg);
15085     }
15086 #endif /* OBJ_ELF */
15087
15088   cur_proc_ptr = NULL;
15089 }
15090
15091 /* The .aent and .ent directives.  */
15092
15093 static void
15094 s_mips_ent (int aent)
15095 {
15096   symbolS *symbolP;
15097
15098   symbolP = get_symbol ();
15099   if (*input_line_pointer == ',')
15100     ++input_line_pointer;
15101   SKIP_WHITESPACE ();
15102   if (ISDIGIT (*input_line_pointer)
15103       || *input_line_pointer == '-')
15104     get_number ();
15105
15106   if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) == 0)
15107     as_warn (_(".ent or .aent not in text section."));
15108
15109   if (!aent && cur_proc_ptr)
15110     as_warn (_("missing .end"));
15111
15112   if (!aent)
15113     {
15114       /* This function needs its own .frame and .cprestore directives.  */
15115       mips_frame_reg_valid = 0;
15116       mips_cprestore_valid = 0;
15117
15118       cur_proc_ptr = &cur_proc;
15119       memset (cur_proc_ptr, '\0', sizeof (procS));
15120
15121       cur_proc_ptr->func_sym = symbolP;
15122
15123       ++numprocs;
15124
15125       if (debug_type == DEBUG_STABS)
15126         stabs_generate_asm_func (S_GET_NAME (symbolP),
15127                                  S_GET_NAME (symbolP));
15128     }
15129
15130   symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
15131
15132   demand_empty_rest_of_line ();
15133 }
15134
15135 /* The .frame directive. If the mdebug section is present (IRIX 5 native)
15136    then ecoff.c (ecoff_directive_frame) is used. For embedded targets,
15137    s_mips_frame is used so that we can set the PDR information correctly.
15138    We can't use the ecoff routines because they make reference to the ecoff
15139    symbol table (in the mdebug section).  */
15140
15141 static void
15142 s_mips_frame (int ignore ATTRIBUTE_UNUSED)
15143 {
15144 #ifdef OBJ_ELF
15145   if (IS_ELF && !ECOFF_DEBUGGING)
15146     {
15147       long val;
15148
15149       if (cur_proc_ptr == (procS *) NULL)
15150         {
15151           as_warn (_(".frame outside of .ent"));
15152           demand_empty_rest_of_line ();
15153           return;
15154         }
15155
15156       cur_proc_ptr->frame_reg = tc_get_register (1);
15157
15158       SKIP_WHITESPACE ();
15159       if (*input_line_pointer++ != ','
15160           || get_absolute_expression_and_terminator (&val) != ',')
15161         {
15162           as_warn (_("Bad .frame directive"));
15163           --input_line_pointer;
15164           demand_empty_rest_of_line ();
15165           return;
15166         }
15167
15168       cur_proc_ptr->frame_offset = val;
15169       cur_proc_ptr->pc_reg = tc_get_register (0);
15170
15171       demand_empty_rest_of_line ();
15172     }
15173   else
15174 #endif /* OBJ_ELF */
15175     s_ignore (ignore);
15176 }
15177
15178 /* The .fmask and .mask directives. If the mdebug section is present
15179    (IRIX 5 native) then ecoff.c (ecoff_directive_mask) is used. For
15180    embedded targets, s_mips_mask is used so that we can set the PDR
15181    information correctly. We can't use the ecoff routines because they
15182    make reference to the ecoff symbol table (in the mdebug section).  */
15183
15184 static void
15185 s_mips_mask (int reg_type)
15186 {
15187 #ifdef OBJ_ELF
15188   if (IS_ELF && !ECOFF_DEBUGGING)
15189     {
15190       long mask, off;
15191
15192       if (cur_proc_ptr == (procS *) NULL)
15193         {
15194           as_warn (_(".mask/.fmask outside of .ent"));
15195           demand_empty_rest_of_line ();
15196           return;
15197         }
15198
15199       if (get_absolute_expression_and_terminator (&mask) != ',')
15200         {
15201           as_warn (_("Bad .mask/.fmask directive"));
15202           --input_line_pointer;
15203           demand_empty_rest_of_line ();
15204           return;
15205         }
15206
15207       off = get_absolute_expression ();
15208
15209       if (reg_type == 'F')
15210         {
15211           cur_proc_ptr->fpreg_mask = mask;
15212           cur_proc_ptr->fpreg_offset = off;
15213         }
15214       else
15215         {
15216           cur_proc_ptr->reg_mask = mask;
15217           cur_proc_ptr->reg_offset = off;
15218         }
15219
15220       demand_empty_rest_of_line ();
15221     }
15222   else
15223 #endif /* OBJ_ELF */
15224     s_ignore (reg_type);
15225 }
15226
15227 /* A table describing all the processors gas knows about.  Names are
15228    matched in the order listed.
15229
15230    To ease comparison, please keep this table in the same order as
15231    gcc's mips_cpu_info_table[].  */
15232 static const struct mips_cpu_info mips_cpu_info_table[] =
15233 {
15234   /* Entries for generic ISAs */
15235   { "mips1",          MIPS_CPU_IS_ISA,          ISA_MIPS1,      CPU_R3000 },
15236   { "mips2",          MIPS_CPU_IS_ISA,          ISA_MIPS2,      CPU_R6000 },
15237   { "mips3",          MIPS_CPU_IS_ISA,          ISA_MIPS3,      CPU_R4000 },
15238   { "mips4",          MIPS_CPU_IS_ISA,          ISA_MIPS4,      CPU_R8000 },
15239   { "mips5",          MIPS_CPU_IS_ISA,          ISA_MIPS5,      CPU_MIPS5 },
15240   { "mips32",         MIPS_CPU_IS_ISA,          ISA_MIPS32,     CPU_MIPS32 },
15241   { "mips32r2",       MIPS_CPU_IS_ISA,          ISA_MIPS32R2,   CPU_MIPS32R2 },
15242   { "mips64",         MIPS_CPU_IS_ISA,          ISA_MIPS64,     CPU_MIPS64 },
15243   { "mips64r2",       MIPS_CPU_IS_ISA,          ISA_MIPS64R2,   CPU_MIPS64R2 },
15244
15245   /* MIPS I */
15246   { "r3000",          0,                        ISA_MIPS1,      CPU_R3000 },
15247   { "r2000",          0,                        ISA_MIPS1,      CPU_R3000 },
15248   { "r3900",          0,                        ISA_MIPS1,      CPU_R3900 },
15249
15250   /* MIPS II */
15251   { "r6000",          0,                        ISA_MIPS2,      CPU_R6000 },
15252
15253   /* MIPS III */
15254   { "r4000",          0,                        ISA_MIPS3,      CPU_R4000 },
15255   { "r4010",          0,                        ISA_MIPS2,      CPU_R4010 },
15256   { "vr4100",         0,                        ISA_MIPS3,      CPU_VR4100 },
15257   { "vr4111",         0,                        ISA_MIPS3,      CPU_R4111 },
15258   { "vr4120",         0,                        ISA_MIPS3,      CPU_VR4120 },
15259   { "vr4130",         0,                        ISA_MIPS3,      CPU_VR4120 },
15260   { "vr4181",         0,                        ISA_MIPS3,      CPU_R4111 },
15261   { "vr4300",         0,                        ISA_MIPS3,      CPU_R4300 },
15262   { "r4400",          0,                        ISA_MIPS3,      CPU_R4400 },
15263   { "r4600",          0,                        ISA_MIPS3,      CPU_R4600 },
15264   { "orion",          0,                        ISA_MIPS3,      CPU_R4600 },
15265   { "r4650",          0,                        ISA_MIPS3,      CPU_R4650 },
15266   /* ST Microelectronics Loongson 2E and 2F cores */
15267   { "loongson2e",     0,                        ISA_MIPS3,   CPU_LOONGSON_2E },
15268   { "loongson2f",     0,                        ISA_MIPS3,   CPU_LOONGSON_2F },
15269
15270   /* MIPS IV */
15271   { "r8000",          0,                        ISA_MIPS4,      CPU_R8000 },
15272   { "r10000",         0,                        ISA_MIPS4,      CPU_R10000 },
15273   { "r12000",         0,                        ISA_MIPS4,      CPU_R12000 },
15274   { "r14000",         0,                        ISA_MIPS4,      CPU_R14000 },
15275   { "r16000",         0,                        ISA_MIPS4,      CPU_R16000 },
15276   { "vr5000",         0,                        ISA_MIPS4,      CPU_R5000 },
15277   { "vr5400",         0,                        ISA_MIPS4,      CPU_VR5400 },
15278   { "vr5500",         0,                        ISA_MIPS4,      CPU_VR5500 },
15279   { "rm5200",         0,                        ISA_MIPS4,      CPU_R5000 },
15280   { "rm5230",         0,                        ISA_MIPS4,      CPU_R5000 },
15281   { "rm5231",         0,                        ISA_MIPS4,      CPU_R5000 },
15282   { "rm5261",         0,                        ISA_MIPS4,      CPU_R5000 },
15283   { "rm5721",         0,                        ISA_MIPS4,      CPU_R5000 },
15284   { "rm7000",         0,                        ISA_MIPS4,      CPU_RM7000 },
15285   { "rm9000",         0,                        ISA_MIPS4,      CPU_RM9000 },
15286
15287   /* MIPS 32 */
15288   { "4kc",            0,                        ISA_MIPS32,     CPU_MIPS32 },
15289   { "4km",            0,                        ISA_MIPS32,     CPU_MIPS32 },
15290   { "4kp",            0,                        ISA_MIPS32,     CPU_MIPS32 },
15291   { "4ksc",           MIPS_CPU_ASE_SMARTMIPS,   ISA_MIPS32,     CPU_MIPS32 },
15292
15293   /* MIPS 32 Release 2 */
15294   { "4kec",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15295   { "4kem",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15296   { "4kep",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15297   { "4ksd",           MIPS_CPU_ASE_SMARTMIPS,   ISA_MIPS32R2,   CPU_MIPS32R2 },
15298   { "m4k",            0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15299   { "m4kp",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15300   { "24kc",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15301   { "24kf2_1",        0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15302   { "24kf",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15303   { "24kf1_1",        0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15304   /* Deprecated forms of the above.  */
15305   { "24kfx",          0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15306   { "24kx",           0,                        ISA_MIPS32R2,   CPU_MIPS32R2 },
15307   /* 24KE is a 24K with DSP ASE, other ASEs are optional.  */
15308   { "24kec",          MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
15309   { "24kef2_1",       MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
15310   { "24kef",          MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
15311   { "24kef1_1",       MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
15312   /* Deprecated forms of the above.  */
15313   { "24kefx",         MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
15314   { "24kex",          MIPS_CPU_ASE_DSP,         ISA_MIPS32R2,   CPU_MIPS32R2 },
15315   /* 34K is a 24K with DSP and MT ASE, other ASEs are optional.  */
15316   { "34kc",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15317                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15318   { "34kf2_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15319                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15320   { "34kf",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15321                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15322   { "34kf1_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15323                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15324   /* Deprecated forms of the above.  */
15325   { "34kfx",          MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15326                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15327   { "34kx",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15328                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15329   /* 74K with DSP and DSPR2 ASE, other ASEs are optional.  */
15330   { "74kc",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
15331                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15332   { "74kf2_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
15333                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15334   { "74kf",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
15335                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15336   { "74kf1_1",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
15337                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15338   { "74kf3_2",        MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
15339                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15340   /* Deprecated forms of the above.  */
15341   { "74kfx",          MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
15342                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15343   { "74kx",           MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_DSPR2,
15344                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15345   /* 1004K cores are multiprocessor versions of the 34K.  */
15346   { "1004kc",         MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15347                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15348   { "1004kf2_1",      MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15349                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15350   { "1004kf",         MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15351                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15352   { "1004kf1_1",      MIPS_CPU_ASE_DSP | MIPS_CPU_ASE_MT,
15353                                                 ISA_MIPS32R2,   CPU_MIPS32R2 },
15354
15355   /* MIPS 64 */
15356   { "5kc",            0,                        ISA_MIPS64,     CPU_MIPS64 },
15357   { "5kf",            0,                        ISA_MIPS64,     CPU_MIPS64 },
15358   { "20kc",           MIPS_CPU_ASE_MIPS3D,      ISA_MIPS64,     CPU_MIPS64 },
15359   { "25kf",           MIPS_CPU_ASE_MIPS3D,      ISA_MIPS64,     CPU_MIPS64 },
15360
15361   /* Broadcom SB-1 CPU core */
15362   { "sb1",            MIPS_CPU_ASE_MIPS3D | MIPS_CPU_ASE_MDMX,
15363                                                 ISA_MIPS64,     CPU_SB1 },
15364   /* Broadcom SB-1A CPU core */
15365   { "sb1a",           MIPS_CPU_ASE_MIPS3D | MIPS_CPU_ASE_MDMX,
15366                                                 ISA_MIPS64,     CPU_SB1 },
15367   
15368   { "loongson3a",     0,                        ISA_MIPS64,     CPU_LOONGSON_3A },
15369
15370   /* MIPS 64 Release 2 */
15371
15372   /* Cavium Networks Octeon CPU core */
15373   { "octeon",         0,      ISA_MIPS64R2,   CPU_OCTEON },
15374
15375   /* RMI Xlr */
15376   { "xlr",            0,      ISA_MIPS64,     CPU_XLR },
15377
15378   /* End marker */
15379   { NULL, 0, 0, 0 }
15380 };
15381
15382
15383 /* Return true if GIVEN is the same as CANONICAL, or if it is CANONICAL
15384    with a final "000" replaced by "k".  Ignore case.
15385
15386    Note: this function is shared between GCC and GAS.  */
15387
15388 static bfd_boolean
15389 mips_strict_matching_cpu_name_p (const char *canonical, const char *given)
15390 {
15391   while (*given != 0 && TOLOWER (*given) == TOLOWER (*canonical))
15392     given++, canonical++;
15393
15394   return ((*given == 0 && *canonical == 0)
15395           || (strcmp (canonical, "000") == 0 && strcasecmp (given, "k") == 0));
15396 }
15397
15398
15399 /* Return true if GIVEN matches CANONICAL, where GIVEN is a user-supplied
15400    CPU name.  We've traditionally allowed a lot of variation here.
15401
15402    Note: this function is shared between GCC and GAS.  */
15403
15404 static bfd_boolean
15405 mips_matching_cpu_name_p (const char *canonical, const char *given)
15406 {
15407   /* First see if the name matches exactly, or with a final "000"
15408      turned into "k".  */
15409   if (mips_strict_matching_cpu_name_p (canonical, given))
15410     return TRUE;
15411
15412   /* If not, try comparing based on numerical designation alone.
15413      See if GIVEN is an unadorned number, or 'r' followed by a number.  */
15414   if (TOLOWER (*given) == 'r')
15415     given++;
15416   if (!ISDIGIT (*given))
15417     return FALSE;
15418
15419   /* Skip over some well-known prefixes in the canonical name,
15420      hoping to find a number there too.  */
15421   if (TOLOWER (canonical[0]) == 'v' && TOLOWER (canonical[1]) == 'r')
15422     canonical += 2;
15423   else if (TOLOWER (canonical[0]) == 'r' && TOLOWER (canonical[1]) == 'm')
15424     canonical += 2;
15425   else if (TOLOWER (canonical[0]) == 'r')
15426     canonical += 1;
15427
15428   return mips_strict_matching_cpu_name_p (canonical, given);
15429 }
15430
15431
15432 /* Parse an option that takes the name of a processor as its argument.
15433    OPTION is the name of the option and CPU_STRING is the argument.
15434    Return the corresponding processor enumeration if the CPU_STRING is
15435    recognized, otherwise report an error and return null.
15436
15437    A similar function exists in GCC.  */
15438
15439 static const struct mips_cpu_info *
15440 mips_parse_cpu (const char *option, const char *cpu_string)
15441 {
15442   const struct mips_cpu_info *p;
15443
15444   /* 'from-abi' selects the most compatible architecture for the given
15445      ABI: MIPS I for 32-bit ABIs and MIPS III for 64-bit ABIs.  For the
15446      EABIs, we have to decide whether we're using the 32-bit or 64-bit
15447      version.  Look first at the -mgp options, if given, otherwise base
15448      the choice on MIPS_DEFAULT_64BIT.
15449
15450      Treat NO_ABI like the EABIs.  One reason to do this is that the
15451      plain 'mips' and 'mips64' configs have 'from-abi' as their default
15452      architecture.  This code picks MIPS I for 'mips' and MIPS III for
15453      'mips64', just as we did in the days before 'from-abi'.  */
15454   if (strcasecmp (cpu_string, "from-abi") == 0)
15455     {
15456       if (ABI_NEEDS_32BIT_REGS (mips_abi))
15457         return mips_cpu_info_from_isa (ISA_MIPS1);
15458
15459       if (ABI_NEEDS_64BIT_REGS (mips_abi))
15460         return mips_cpu_info_from_isa (ISA_MIPS3);
15461
15462       if (file_mips_gp32 >= 0)
15463         return mips_cpu_info_from_isa (file_mips_gp32 ? ISA_MIPS1 : ISA_MIPS3);
15464
15465       return mips_cpu_info_from_isa (MIPS_DEFAULT_64BIT
15466                                      ? ISA_MIPS3
15467                                      : ISA_MIPS1);
15468     }
15469
15470   /* 'default' has traditionally been a no-op.  Probably not very useful.  */
15471   if (strcasecmp (cpu_string, "default") == 0)
15472     return 0;
15473
15474   for (p = mips_cpu_info_table; p->name != 0; p++)
15475     if (mips_matching_cpu_name_p (p->name, cpu_string))
15476       return p;
15477
15478   as_bad (_("Bad value (%s) for %s"), cpu_string, option);
15479   return 0;
15480 }
15481
15482 /* Return the canonical processor information for ISA (a member of the
15483    ISA_MIPS* enumeration).  */
15484
15485 static const struct mips_cpu_info *
15486 mips_cpu_info_from_isa (int isa)
15487 {
15488   int i;
15489
15490   for (i = 0; mips_cpu_info_table[i].name != NULL; i++)
15491     if ((mips_cpu_info_table[i].flags & MIPS_CPU_IS_ISA)
15492         && isa == mips_cpu_info_table[i].isa)
15493       return (&mips_cpu_info_table[i]);
15494
15495   return NULL;
15496 }
15497
15498 static const struct mips_cpu_info *
15499 mips_cpu_info_from_arch (int arch)
15500 {
15501   int i;
15502
15503   for (i = 0; mips_cpu_info_table[i].name != NULL; i++)
15504     if (arch == mips_cpu_info_table[i].cpu)
15505       return (&mips_cpu_info_table[i]);
15506
15507   return NULL;
15508 }
15509 \f
15510 static void
15511 show (FILE *stream, const char *string, int *col_p, int *first_p)
15512 {
15513   if (*first_p)
15514     {
15515       fprintf (stream, "%24s", "");
15516       *col_p = 24;
15517     }
15518   else
15519     {
15520       fprintf (stream, ", ");
15521       *col_p += 2;
15522     }
15523
15524   if (*col_p + strlen (string) > 72)
15525     {
15526       fprintf (stream, "\n%24s", "");
15527       *col_p = 24;
15528     }
15529
15530   fprintf (stream, "%s", string);
15531   *col_p += strlen (string);
15532
15533   *first_p = 0;
15534 }
15535
15536 void
15537 md_show_usage (FILE *stream)
15538 {
15539   int column, first;
15540   size_t i;
15541
15542   fprintf (stream, _("\
15543 MIPS options:\n\
15544 -EB                     generate big endian output\n\
15545 -EL                     generate little endian output\n\
15546 -g, -g2                 do not remove unneeded NOPs or swap branches\n\
15547 -G NUM                  allow referencing objects up to NUM bytes\n\
15548                         implicitly with the gp register [default 8]\n"));
15549   fprintf (stream, _("\
15550 -mips1                  generate MIPS ISA I instructions\n\
15551 -mips2                  generate MIPS ISA II instructions\n\
15552 -mips3                  generate MIPS ISA III instructions\n\
15553 -mips4                  generate MIPS ISA IV instructions\n\
15554 -mips5                  generate MIPS ISA V instructions\n\
15555 -mips32                 generate MIPS32 ISA instructions\n\
15556 -mips32r2               generate MIPS32 release 2 ISA instructions\n\
15557 -mips64                 generate MIPS64 ISA instructions\n\
15558 -mips64r2               generate MIPS64 release 2 ISA instructions\n\
15559 -march=CPU/-mtune=CPU   generate code/schedule for CPU, where CPU is one of:\n"));
15560
15561   first = 1;
15562
15563   for (i = 0; mips_cpu_info_table[i].name != NULL; i++)
15564     show (stream, mips_cpu_info_table[i].name, &column, &first);
15565   show (stream, "from-abi", &column, &first);
15566   fputc ('\n', stream);
15567
15568   fprintf (stream, _("\
15569 -mCPU                   equivalent to -march=CPU -mtune=CPU. Deprecated.\n\
15570 -no-mCPU                don't generate code specific to CPU.\n\
15571                         For -mCPU and -no-mCPU, CPU must be one of:\n"));
15572
15573   first = 1;
15574
15575   show (stream, "3900", &column, &first);
15576   show (stream, "4010", &column, &first);
15577   show (stream, "4100", &column, &first);
15578   show (stream, "4650", &column, &first);
15579   fputc ('\n', stream);
15580
15581   fprintf (stream, _("\
15582 -mips16                 generate mips16 instructions\n\
15583 -no-mips16              do not generate mips16 instructions\n"));
15584   fprintf (stream, _("\
15585 -msmartmips             generate smartmips instructions\n\
15586 -mno-smartmips          do not generate smartmips instructions\n"));  
15587   fprintf (stream, _("\
15588 -mdsp                   generate DSP instructions\n\
15589 -mno-dsp                do not generate DSP instructions\n"));
15590   fprintf (stream, _("\
15591 -mdspr2                 generate DSP R2 instructions\n\
15592 -mno-dspr2              do not generate DSP R2 instructions\n"));
15593   fprintf (stream, _("\
15594 -mmt                    generate MT instructions\n\
15595 -mno-mt                 do not generate MT instructions\n"));
15596   fprintf (stream, _("\
15597 -mfix-loongson2f-jump   work around Loongson2F JUMP instructions\n\
15598 -mfix-loongson2f-nop    work around Loongson2F NOP errata\n\
15599 -mfix-vr4120            work around certain VR4120 errata\n\
15600 -mfix-vr4130            work around VR4130 mflo/mfhi errata\n\
15601 -mfix-24k               insert a nop after ERET and DERET instructions\n\
15602 -mfix-cn63xxp1          work around CN63XXP1 PREF errata\n\
15603 -mgp32                  use 32-bit GPRs, regardless of the chosen ISA\n\
15604 -mfp32                  use 32-bit FPRs, regardless of the chosen ISA\n\
15605 -msym32                 assume all symbols have 32-bit values\n\
15606 -O0                     remove unneeded NOPs, do not swap branches\n\
15607 -O                      remove unneeded NOPs and swap branches\n\
15608 --trap, --no-break      trap exception on div by 0 and mult overflow\n\
15609 --break, --no-trap      break exception on div by 0 and mult overflow\n"));
15610   fprintf (stream, _("\
15611 -mhard-float            allow floating-point instructions\n\
15612 -msoft-float            do not allow floating-point instructions\n\
15613 -msingle-float          only allow 32-bit floating-point operations\n\
15614 -mdouble-float          allow 32-bit and 64-bit floating-point operations\n\
15615 --[no-]construct-floats [dis]allow floating point values to be constructed\n"
15616                      ));
15617 #ifdef OBJ_ELF
15618   fprintf (stream, _("\
15619 -KPIC, -call_shared     generate SVR4 position independent code\n\
15620 -call_nonpic            generate non-PIC code that can operate with DSOs\n\
15621 -mvxworks-pic           generate VxWorks position independent code\n\
15622 -non_shared             do not generate code that can operate with DSOs\n\
15623 -xgot                   assume a 32 bit GOT\n\
15624 -mpdr, -mno-pdr         enable/disable creation of .pdr sections\n\
15625 -mshared, -mno-shared   disable/enable .cpload optimization for\n\
15626                         position dependent (non shared) code\n\
15627 -mabi=ABI               create ABI conformant object file for:\n"));
15628
15629   first = 1;
15630
15631   show (stream, "32", &column, &first);
15632   show (stream, "o64", &column, &first);
15633   show (stream, "n32", &column, &first);
15634   show (stream, "64", &column, &first);
15635   show (stream, "eabi", &column, &first);
15636
15637   fputc ('\n', stream);
15638
15639   fprintf (stream, _("\
15640 -32                     create o32 ABI object file (default)\n\
15641 -n32                    create n32 ABI object file\n\
15642 -64                     create 64 ABI object file\n"));
15643 #endif
15644 }
15645
15646 #ifdef TE_IRIX
15647 enum dwarf2_format
15648 mips_dwarf2_format (asection *sec ATTRIBUTE_UNUSED)
15649 {
15650   if (HAVE_64BIT_SYMBOLS)
15651     return dwarf2_format_64bit_irix;
15652   else
15653     return dwarf2_format_32bit;
15654 }
15655 #endif
15656
15657 int
15658 mips_dwarf2_addr_size (void)
15659 {
15660   if (HAVE_64BIT_OBJECTS)
15661     return 8;
15662   else
15663     return 4;
15664 }
15665
15666 /* Standard calling conventions leave the CFA at SP on entry.  */
15667 void
15668 mips_cfi_frame_initial_instructions (void)
15669 {
15670   cfi_add_CFA_def_cfa_register (SP);
15671 }
15672
15673 int
15674 tc_mips_regname_to_dw2regnum (char *regname)
15675 {
15676   unsigned int regnum = -1;
15677   unsigned int reg;
15678
15679   if (reg_lookup (&regname, RTYPE_GP | RTYPE_NUM, &reg))
15680     regnum = reg;
15681
15682   return regnum;
15683 }