1 /* tc-mips.c -- assemble code for a MIPS chip.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
3 Contributed by the OSF and Ralph Campbell.
4 Written by Keith Knowles and Ralph Campbell, working independently.
5 Modified for ECOFF and R4000 support by Ian Lance Taylor of Cygnus
8 This file is part of GAS.
10 GAS is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 GAS is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GAS; see the file COPYING. If not, write to the Free
22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
38 #include "opcode/mips.h"
41 /* Clean up namespace so we can include obj-elf.h too. */
42 static int mips_output_flavor () { return OUTPUT_FLAVOR
; }
43 #undef OBJ_PROCESS_STAB
49 #undef TARGET_SYMBOL_FIELDS
51 #undef obj_frob_file_after_relocs
52 #undef obj_frob_symbol
54 #undef obj_sec_sym_ok_for_reloc
57 /* Fix any of them that we actually care about. */
59 #define OUTPUT_FLAVOR mips_output_flavor()
66 #ifndef ECOFF_DEBUGGING
67 #define NO_ECOFF_DEBUGGING
68 #define ECOFF_DEBUGGING 0
73 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
74 static char *mips_regmask_frag
;
79 #define PIC_CALL_REG 25
87 #define ILLEGAL_REG (32)
89 extern int target_big_endian
;
91 /* 1 is we should use the 64 bit MIPS ELF ABI, 0 if we should use the
92 32 bit ABI. This has no meaning for ECOFF. */
95 /* The default target format to use. */
99 switch (OUTPUT_FLAVOR
)
101 case bfd_target_aout_flavour
:
102 return target_big_endian
? "a.out-mips-big" : "a.out-mips-little";
103 case bfd_target_ecoff_flavour
:
104 return target_big_endian
? "ecoff-bigmips" : "ecoff-littlemips";
105 case bfd_target_elf_flavour
:
106 return (target_big_endian
107 ? (mips_64
? "elf64-bigmips" : "elf32-bigmips")
108 : (mips_64
? "elf64-littlemips" : "elf32-littlemips"));
114 /* The name of the readonly data section. */
115 #define RDATA_SECTION_NAME (OUTPUT_FLAVOR == bfd_target_aout_flavour \
117 : OUTPUT_FLAVOR == bfd_target_ecoff_flavour \
119 : OUTPUT_FLAVOR == bfd_target_elf_flavour \
123 /* These variables are filled in with the masks of registers used.
124 The object format code reads them and puts them in the appropriate
126 unsigned long mips_gprmask
;
127 unsigned long mips_cprmask
[4];
129 /* MIPS ISA (Instruction Set Architecture) level (may be changed
130 temporarily using .set mipsN). */
131 static int mips_isa
= -1;
133 /* MIPS ISA we are using for this output file. */
134 static int file_mips_isa
;
136 /* Whether we are assembling for the mips16 processor. */
137 static int mips16
= -1;
139 /* The CPU type as a number: 2000, 3000, 4000, 4400, etc. */
140 static int mips_cpu
= -1;
142 /* Whether the 4650 instructions (mad/madu) are permitted. */
143 static int mips_4650
= -1;
145 /* Whether the 4010 instructions are permitted. */
146 static int mips_4010
= -1;
148 /* Whether the 4100 MADD16 and DMADD16 are permitted. */
149 static int mips_4100
= -1;
151 /* start-sanitize-r5900 */
152 /* Whether Toshiba r5900 instructions are permitted. */
153 static int mips_5900
= -1;
154 /* end-sanitize-r5900 */
156 /* Whether the processor uses hardware interlocks, and thus does not
157 require nops to be inserted. */
158 static int interlocks
= -1;
160 /* As with "interlocks" this is used by hardware that has FP
161 (co-processor) interlocks. */
162 static int cop_interlocks
= -1;
164 /* MIPS PIC level. */
168 /* Do not generate PIC code. */
171 /* Generate PIC code as in Irix 4. This is not implemented, and I'm
172 not sure what it is supposed to do. */
175 /* Generate PIC code as in the SVR4 MIPS ABI. */
178 /* Generate PIC code without using a global offset table: the data
179 segment has a maximum size of 64K, all data references are off
180 the $gp register, and all text references are PC relative. This
181 is used on some embedded systems. */
185 static enum mips_pic_level mips_pic
;
187 /* 1 if we should generate 32 bit offsets from the GP register in
188 SVR4_PIC mode. Currently has no meaning in other modes. */
189 static int mips_big_got
;
191 /* 1 if trap instructions should used for overflow rather than break
193 static int mips_trap
;
195 /* 1 if we should autoextend mips16 instructions. */
196 static int mips16_autoextend
= 1;
198 static int mips_warn_about_macros
;
199 static int mips_noreorder
;
200 static int mips_any_noreorder
;
201 static int mips_nomove
;
202 static int mips_noat
;
203 static int mips_nobopt
;
205 /* The size of the small data section. */
206 static int g_switch_value
= 8;
207 /* Whether the -G option was used. */
208 static int g_switch_seen
= 0;
213 /* If we can determine in advance that GP optimization won't be
214 possible, we can skip the relaxation stuff that tries to produce
215 GP-relative references. This makes delay slot optimization work
218 This function can only provide a guess, but it seems to work for
219 gcc output. If it guesses wrong, the only loss should be in
220 efficiency; it shouldn't introduce any bugs.
222 I don't know if a fix is needed for the SVR4_PIC mode. I've only
223 fixed it for the non-PIC mode. KR 95/04/07 */
224 static int nopic_need_relax
PARAMS ((symbolS
*));
226 /* handle of the OPCODE hash table */
227 static struct hash_control
*op_hash
= NULL
;
229 /* The opcode hash table we use for the mips16. */
230 static struct hash_control
*mips16_op_hash
= NULL
;
232 /* This array holds the chars that always start a comment. If the
233 pre-processor is disabled, these aren't very useful */
234 const char comment_chars
[] = "#";
236 /* This array holds the chars that only start a comment at the beginning of
237 a line. If the line seems to have the form '# 123 filename'
238 .line and .file directives will appear in the pre-processed output */
239 /* Note that input_file.c hand checks for '#' at the beginning of the
240 first line of the input file. This is because the compiler outputs
241 #NO_APP at the beginning of its output. */
242 /* Also note that C style comments are always supported. */
243 const char line_comment_chars
[] = "#";
245 /* This array holds machine specific line separator characters. */
246 const char line_separator_chars
[] = "";
248 /* Chars that can be used to separate mant from exp in floating point nums */
249 const char EXP_CHARS
[] = "eE";
251 /* Chars that mean this number is a floating point constant */
254 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
256 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
257 changed in read.c . Ideally it shouldn't have to know about it at all,
258 but nothing is ideal around here.
261 static char *insn_error
;
263 static int auto_align
= 1;
265 /* When outputting SVR4 PIC code, the assembler needs to know the
266 offset in the stack frame from which to restore the $gp register.
267 This is set by the .cprestore pseudo-op, and saved in this
269 static offsetT mips_cprestore_offset
= -1;
271 /* This is the register which holds the stack frame, as set by the
272 .frame pseudo-op. This is needed to implement .cprestore. */
273 static int mips_frame_reg
= SP
;
275 /* To output NOP instructions correctly, we need to keep information
276 about the previous two instructions. */
278 /* Whether we are optimizing. The default value of 2 means to remove
279 unneeded NOPs and swap branch instructions when possible. A value
280 of 1 means to not swap branches. A value of 0 means to always
282 static int mips_optimize
= 2;
284 /* Debugging level. -g sets this to 2. -gN sets this to N. -g0 is
285 equivalent to seeing no -g option at all. */
286 static int mips_debug
= 0;
288 /* The previous instruction. */
289 static struct mips_cl_insn prev_insn
;
291 /* The instruction before prev_insn. */
292 static struct mips_cl_insn prev_prev_insn
;
294 /* If we don't want information for prev_insn or prev_prev_insn, we
295 point the insn_mo field at this dummy integer. */
296 static const struct mips_opcode dummy_opcode
= { 0 };
298 /* Non-zero if prev_insn is valid. */
299 static int prev_insn_valid
;
301 /* The frag for the previous instruction. */
302 static struct frag
*prev_insn_frag
;
304 /* The offset into prev_insn_frag for the previous instruction. */
305 static long prev_insn_where
;
307 /* The reloc type for the previous instruction, if any. */
308 static bfd_reloc_code_real_type prev_insn_reloc_type
;
310 /* The reloc for the previous instruction, if any. */
311 static fixS
*prev_insn_fixp
;
313 /* Non-zero if the previous instruction was in a delay slot. */
314 static int prev_insn_is_delay_slot
;
316 /* Non-zero if the previous instruction was in a .set noreorder. */
317 static int prev_insn_unreordered
;
319 /* Non-zero if the previous instruction uses an extend opcode (if
321 static int prev_insn_extended
;
323 /* Non-zero if the previous previous instruction was in a .set
325 static int prev_prev_insn_unreordered
;
327 /* For ECOFF and ELF, relocations against symbols are done in two
328 parts, with a HI relocation and a LO relocation. Each relocation
329 has only 16 bits of space to store an addend. This means that in
330 order for the linker to handle carries correctly, it must be able
331 to locate both the HI and the LO relocation. This means that the
332 relocations must appear in order in the relocation table.
334 In order to implement this, we keep track of each unmatched HI
335 relocation. We then sort them so that they immediately precede the
336 corresponding LO relocation. */
341 struct mips_hi_fixup
*next
;
344 /* The section this fixup is in. */
348 /* The list of unmatched HI relocs. */
350 static struct mips_hi_fixup
*mips_hi_fixup_list
;
352 /* Map normal MIPS register numbers to mips16 register numbers. */
354 #define X ILLEGAL_REG
355 static const int mips32_to_16_reg_map
[] =
357 X
, X
, 2, 3, 4, 5, 6, 7,
358 X
, X
, X
, X
, X
, X
, X
, X
,
359 0, 1, X
, X
, X
, X
, X
, X
,
360 X
, X
, X
, X
, X
, X
, X
, X
364 /* Map mips16 register numbers to normal MIPS register numbers. */
366 static const int mips16_to_32_reg_map
[] =
368 16, 17, 2, 3, 4, 5, 6, 7
371 /* Since the MIPS does not have multiple forms of PC relative
372 instructions, we do not have to do relaxing as is done on other
373 platforms. However, we do have to handle GP relative addressing
374 correctly, which turns out to be a similar problem.
376 Every macro that refers to a symbol can occur in (at least) two
377 forms, one with GP relative addressing and one without. For
378 example, loading a global variable into a register generally uses
379 a macro instruction like this:
381 If i can be addressed off the GP register (this is true if it is in
382 the .sbss or .sdata section, or if it is known to be smaller than
383 the -G argument) this will generate the following instruction:
385 This instruction will use a GPREL reloc. If i can not be addressed
386 off the GP register, the following instruction sequence will be used:
389 In this case the first instruction will have a HI16 reloc, and the
390 second reloc will have a LO16 reloc. Both relocs will be against
393 The issue here is that we may not know whether i is GP addressable
394 until after we see the instruction that uses it. Therefore, we
395 want to be able to choose the final instruction sequence only at
396 the end of the assembly. This is similar to the way other
397 platforms choose the size of a PC relative instruction only at the
400 When generating position independent code we do not use GP
401 addressing in quite the same way, but the issue still arises as
402 external symbols and local symbols must be handled differently.
404 We handle these issues by actually generating both possible
405 instruction sequences. The longer one is put in a frag_var with
406 type rs_machine_dependent. We encode what to do with the frag in
407 the subtype field. We encode (1) the number of existing bytes to
408 replace, (2) the number of new bytes to use, (3) the offset from
409 the start of the existing bytes to the first reloc we must generate
410 (that is, the offset is applied from the start of the existing
411 bytes after they are replaced by the new bytes, if any), (4) the
412 offset from the start of the existing bytes to the second reloc,
413 (5) whether a third reloc is needed (the third reloc is always four
414 bytes after the second reloc), and (6) whether to warn if this
415 variant is used (this is sometimes needed if .set nomacro or .set
416 noat is in effect). All these numbers are reasonably small.
418 Generating two instruction sequences must be handled carefully to
419 ensure that delay slots are handled correctly. Fortunately, there
420 are a limited number of cases. When the second instruction
421 sequence is generated, append_insn is directed to maintain the
422 existing delay slot information, so it continues to apply to any
423 code after the second instruction sequence. This means that the
424 second instruction sequence must not impose any requirements not
425 required by the first instruction sequence.
427 These variant frags are then handled in functions called by the
428 machine independent code. md_estimate_size_before_relax returns
429 the final size of the frag. md_convert_frag sets up the final form
430 of the frag. tc_gen_reloc adjust the first reloc and adds a second
432 #define RELAX_ENCODE(old, new, reloc1, reloc2, reloc3, warn) \
436 | (((reloc1) + 64) << 9) \
437 | (((reloc2) + 64) << 2) \
438 | ((reloc3) ? (1 << 1) : 0) \
440 #define RELAX_OLD(i) (((i) >> 23) & 0x7f)
441 #define RELAX_NEW(i) (((i) >> 16) & 0x7f)
442 #define RELAX_RELOC1(i) ((bfd_vma)(((i) >> 9) & 0x7f) - 64)
443 #define RELAX_RELOC2(i) ((bfd_vma)(((i) >> 2) & 0x7f) - 64)
444 #define RELAX_RELOC3(i) (((i) >> 1) & 1)
445 #define RELAX_WARN(i) ((i) & 1)
447 /* For mips16 code, we use an entirely different form of relaxation.
448 mips16 supports two versions of most instructions which take
449 immediate values: a small one which takes some small value, and a
450 larger one which takes a 16 bit value. Since branches also follow
451 this pattern, relaxing these values is required.
453 We can assemble both mips16 and normal MIPS code in a single
454 object. Therefore, we need to support this type of relaxation at
455 the same time that we support the relaxation described above. We
456 use the high bit of the subtype field to distinguish these cases.
458 The information we store for this type of relaxation is the
459 argument code found in the opcode file for this relocation, whether
460 the user explicitly requested a small or extended form, and whether
461 the relocation is in a jump or jal delay slot. That tells us the
462 size of the value, and how it should be stored. We also store
463 whether the fragment is considered to be extended or not. We also
464 store whether this is known to be a branch to a different section,
465 whether we have tried to relax this frag yet, and whether we have
466 ever extended a PC relative fragment because of a shift count. */
467 #define RELAX_MIPS16_ENCODE(type, small, ext, dslot, jal_dslot) \
470 | ((small) ? 0x100 : 0) \
471 | ((ext) ? 0x200 : 0) \
472 | ((dslot) ? 0x400 : 0) \
473 | ((jal_dslot) ? 0x800 : 0))
474 #define RELAX_MIPS16_P(i) (((i) & 0x80000000) != 0)
475 #define RELAX_MIPS16_TYPE(i) ((i) & 0xff)
476 #define RELAX_MIPS16_USER_SMALL(i) (((i) & 0x100) != 0)
477 #define RELAX_MIPS16_USER_EXT(i) (((i) & 0x200) != 0)
478 #define RELAX_MIPS16_DSLOT(i) (((i) & 0x400) != 0)
479 #define RELAX_MIPS16_JAL_DSLOT(i) (((i) & 0x800) != 0)
480 #define RELAX_MIPS16_EXTENDED(i) (((i) & 0x1000) != 0)
481 #define RELAX_MIPS16_MARK_EXTENDED(i) ((i) | 0x1000)
482 #define RELAX_MIPS16_CLEAR_EXTENDED(i) ((i) &~ 0x1000)
483 #define RELAX_MIPS16_LONG_BRANCH(i) (((i) & 0x2000) != 0)
484 #define RELAX_MIPS16_MARK_LONG_BRANCH(i) ((i) | 0x2000)
485 #define RELAX_MIPS16_CLEAR_LONG_BRANCH(i) ((i) &~ 0x2000)
487 /* Prototypes for static functions. */
490 #define internalError() \
491 as_fatal ("internal Error, line %d, %s", __LINE__, __FILE__)
493 #define internalError() as_fatal ("MIPS internal Error");
496 enum mips_regclass
{ MIPS_GR_REG
, MIPS_FP_REG
, MIPS16_REG
};
498 static int insn_uses_reg
PARAMS ((struct mips_cl_insn
*ip
,
499 unsigned int reg
, enum mips_regclass
class));
500 static int reg_needs_delay
PARAMS ((int));
501 static void append_insn
PARAMS ((char *place
,
502 struct mips_cl_insn
* ip
,
504 bfd_reloc_code_real_type r
,
506 static void mips_no_prev_insn
PARAMS ((void));
507 static void mips_emit_delays
PARAMS ((boolean
));
509 static void macro_build
PARAMS ((char *place
, int *counter
, expressionS
* ep
,
510 const char *name
, const char *fmt
,
513 static void macro_build ();
515 static void mips16_macro_build
PARAMS ((char *, int *, expressionS
*,
516 const char *, const char *,
518 static void macro_build_lui
PARAMS ((char *place
, int *counter
,
519 expressionS
* ep
, int regnum
));
520 static void set_at
PARAMS ((int *counter
, int reg
, int unsignedp
));
521 static void check_absolute_expr
PARAMS ((struct mips_cl_insn
* ip
,
523 static void load_register
PARAMS ((int *, int, expressionS
*, int));
524 static void load_address
PARAMS ((int *counter
, int reg
, expressionS
*ep
));
525 static void macro
PARAMS ((struct mips_cl_insn
* ip
));
526 static void mips16_macro
PARAMS ((struct mips_cl_insn
* ip
));
527 #ifdef LOSING_COMPILER
528 static void macro2
PARAMS ((struct mips_cl_insn
* ip
));
530 static void mips_ip
PARAMS ((char *str
, struct mips_cl_insn
* ip
));
531 static void mips16_ip
PARAMS ((char *str
, struct mips_cl_insn
* ip
));
532 static void mips16_immed
PARAMS ((char *, unsigned int, int, offsetT
, boolean
,
533 boolean
, boolean
, unsigned long *,
534 boolean
*, unsigned short *));
535 static int my_getSmallExpression
PARAMS ((expressionS
* ep
, char *str
));
536 static void my_getExpression
PARAMS ((expressionS
* ep
, char *str
));
537 static symbolS
*get_symbol
PARAMS ((void));
538 static void mips_align
PARAMS ((int to
, int fill
, symbolS
*label
));
539 static void s_align
PARAMS ((int));
540 static void s_change_sec
PARAMS ((int));
541 static void s_cons
PARAMS ((int));
542 static void s_float_cons
PARAMS ((int));
543 static void s_mips_globl
PARAMS ((int));
544 static void s_option
PARAMS ((int));
545 static void s_mipsset
PARAMS ((int));
546 static void s_abicalls
PARAMS ((int));
547 static void s_cpload
PARAMS ((int));
548 static void s_cprestore
PARAMS ((int));
549 static void s_gpword
PARAMS ((int));
550 static void s_cpadd
PARAMS ((int));
551 static void s_insn
PARAMS ((int));
552 static void md_obj_begin
PARAMS ((void));
553 static void md_obj_end
PARAMS ((void));
554 static long get_number
PARAMS ((void));
555 static void s_ent
PARAMS ((int));
556 static void s_mipsend
PARAMS ((int));
557 static void s_file
PARAMS ((int));
558 static int mips16_extended_frag
PARAMS ((fragS
*, asection
*, long));
562 The following pseudo-ops from the Kane and Heinrich MIPS book
563 should be defined here, but are currently unsupported: .alias,
564 .galive, .gjaldef, .gjrlive, .livereg, .noalias.
566 The following pseudo-ops from the Kane and Heinrich MIPS book are
567 specific to the type of debugging information being generated, and
568 should be defined by the object format: .aent, .begin, .bend,
569 .bgnb, .end, .endb, .ent, .fmask, .frame, .loc, .mask, .verstamp,
572 The following pseudo-ops from the Kane and Heinrich MIPS book are
573 not MIPS CPU specific, but are also not specific to the object file
574 format. This file is probably the best place to define them, but
575 they are not currently supported: .asm0, .endr, .lab, .repeat,
576 .struct, .weakext. */
578 static const pseudo_typeS mips_pseudo_table
[] =
580 /* MIPS specific pseudo-ops. */
581 {"option", s_option
, 0},
582 {"set", s_mipsset
, 0},
583 {"rdata", s_change_sec
, 'r'},
584 {"sdata", s_change_sec
, 's'},
585 {"livereg", s_ignore
, 0},
586 {"abicalls", s_abicalls
, 0},
587 {"cpload", s_cpload
, 0},
588 {"cprestore", s_cprestore
, 0},
589 {"gpword", s_gpword
, 0},
590 {"cpadd", s_cpadd
, 0},
593 /* Relatively generic pseudo-ops that happen to be used on MIPS
595 {"asciiz", stringer
, 1},
596 {"bss", s_change_sec
, 'b'},
599 {"dword", s_cons
, 3},
601 /* These pseudo-ops are defined in read.c, but must be overridden
602 here for one reason or another. */
603 {"align", s_align
, 0},
605 {"data", s_change_sec
, 'd'},
606 {"double", s_float_cons
, 'd'},
607 {"float", s_float_cons
, 'f'},
608 {"globl", s_mips_globl
, 0},
609 {"global", s_mips_globl
, 0},
610 {"hword", s_cons
, 1},
615 {"short", s_cons
, 1},
616 {"single", s_float_cons
, 'f'},
617 {"text", s_change_sec
, 't'},
622 static const pseudo_typeS mips_nonecoff_pseudo_table
[] = {
623 /* These pseudo-ops should be defined by the object file format.
624 However, a.out doesn't support them, so we have versions here. */
626 {"bgnb", s_ignore
, 0},
627 {"end", s_mipsend
, 0},
628 {"endb", s_ignore
, 0},
631 {"fmask", s_ignore
, 'F'},
632 {"frame", s_ignore
, 0},
633 {"loc", s_ignore
, 0},
634 {"mask", s_ignore
, 'R'},
635 {"verstamp", s_ignore
, 0},
639 extern void pop_insert
PARAMS ((const pseudo_typeS
*));
644 pop_insert (mips_pseudo_table
);
645 if (! ECOFF_DEBUGGING
)
646 pop_insert (mips_nonecoff_pseudo_table
);
649 /* Symbols labelling the current insn. */
651 struct insn_label_list
653 struct insn_label_list
*next
;
657 static struct insn_label_list
*insn_labels
;
658 static struct insn_label_list
*free_insn_labels
;
660 static void mips_clear_insn_labels
PARAMS ((void));
663 mips_clear_insn_labels ()
665 register struct insn_label_list
**pl
;
667 for (pl
= &free_insn_labels
; *pl
!= NULL
; pl
= &(*pl
)->next
)
673 static char *expr_end
;
675 /* Expressions which appear in instructions. These are set by
678 static expressionS imm_expr
;
679 static expressionS offset_expr
;
681 /* Relocs associated with imm_expr and offset_expr. */
683 static bfd_reloc_code_real_type imm_reloc
;
684 static bfd_reloc_code_real_type offset_reloc
;
686 /* This is set by mips_ip if imm_reloc is an unmatched HI16_S reloc. */
688 static boolean imm_unmatched_hi
;
690 /* These are set by mips16_ip if an explicit extension is used. */
692 static boolean mips16_small
, mips16_ext
;
695 * This function is called once, at assembler startup time. It should
696 * set up all the tables, etc. that the MD part of the assembler will need.
702 register const char *retval
= NULL
;
703 register unsigned int i
= 0;
711 if (strcmp (cpu
+ (sizeof TARGET_CPU
) - 3, "el") == 0)
713 a
= xmalloc (sizeof TARGET_CPU
);
714 strcpy (a
, TARGET_CPU
);
715 a
[(sizeof TARGET_CPU
) - 3] = '\0';
719 if (strcmp (cpu
, "mips") == 0)
725 else if (strcmp (cpu
, "r6000") == 0
726 || strcmp (cpu
, "mips2") == 0)
732 else if (strcmp (cpu
, "mips64") == 0
733 || strcmp (cpu
, "r4000") == 0
734 || strcmp (cpu
, "mips3") == 0)
740 else if (strcmp (cpu
, "r4400") == 0)
746 else if (strcmp (cpu
, "mips64orion") == 0
747 || strcmp (cpu
, "r4600") == 0)
753 else if (strcmp (cpu
, "r4650") == 0)
761 else if (strcmp (cpu
, "mips64vr4300") == 0)
767 else if (strcmp (cpu
, "mips64vr4100") == 0)
775 else if (strcmp (cpu
, "r4010") == 0)
783 else if (strcmp (cpu
, "r5000") == 0
784 || strcmp (cpu
, "mips64vr5000") == 0)
790 /* start-sanitize-r5900 */
791 else if (strcmp (cpu
, "r5900") == 0
792 || strcmp (cpu
, "mips64vr5900") == 0
793 || strcmp (cpu
, "mips64vr5900el") == 0)
801 /* end-sanitize-r5900 */
802 else if (strcmp (cpu
, "r8000") == 0
803 || strcmp (cpu
, "mips4") == 0)
809 else if (strcmp (cpu
, "r10000") == 0)
815 else if (strcmp (cpu
, "mips16") == 0)
819 mips_cpu
= 0; /* FIXME */
834 if (strncmp (TARGET_CPU
, "mips16", sizeof "mips16" - 1) == 0)
849 /* start-sanitize-r5900 */
852 /* end-sanitize-r5900 */
854 if (mips_4010
|| mips_4100
|| mips_cpu
== 4300)
859 if (mips_cpu
== 4300)
864 if (mips_isa
< 2 && mips_trap
)
865 as_bad ("trap exception not supported at ISA 1");
870 ok
= bfd_set_arch_mach (stdoutput
, bfd_arch_mips
, 3000);
873 ok
= bfd_set_arch_mach (stdoutput
, bfd_arch_mips
, 6000);
876 ok
= bfd_set_arch_mach (stdoutput
, bfd_arch_mips
, 4000);
879 ok
= bfd_set_arch_mach (stdoutput
, bfd_arch_mips
, 8000);
883 as_warn ("Could not set architecture and machine");
885 file_mips_isa
= mips_isa
;
887 op_hash
= hash_new ();
889 for (i
= 0; i
< NUMOPCODES
;)
891 const char *name
= mips_opcodes
[i
].name
;
893 retval
= hash_insert (op_hash
, name
, (PTR
) &mips_opcodes
[i
]);
896 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
897 mips_opcodes
[i
].name
, retval
);
898 as_fatal ("Broken assembler. No assembly attempted.");
902 if (mips_opcodes
[i
].pinfo
!= INSN_MACRO
903 && ((mips_opcodes
[i
].match
& mips_opcodes
[i
].mask
)
904 != mips_opcodes
[i
].match
))
906 fprintf (stderr
, "internal error: bad opcode: `%s' \"%s\"\n",
907 mips_opcodes
[i
].name
, mips_opcodes
[i
].args
);
908 as_fatal ("Broken assembler. No assembly attempted.");
912 while ((i
< NUMOPCODES
) && !strcmp (mips_opcodes
[i
].name
, name
));
915 mips16_op_hash
= hash_new ();
918 while (i
< bfd_mips16_num_opcodes
)
920 const char *name
= mips16_opcodes
[i
].name
;
922 retval
= hash_insert (mips16_op_hash
, name
, (PTR
) &mips16_opcodes
[i
]);
924 as_fatal ("internal error: can't hash `%s': %s\n",
925 mips16_opcodes
[i
].name
, retval
);
928 if (mips16_opcodes
[i
].pinfo
!= INSN_MACRO
929 && ((mips16_opcodes
[i
].match
& mips16_opcodes
[i
].mask
)
930 != mips16_opcodes
[i
].match
))
931 as_fatal ("internal error: bad opcode: `%s' \"%s\"\n",
932 mips16_opcodes
[i
].name
, mips16_opcodes
[i
].args
);
935 while (i
< bfd_mips16_num_opcodes
936 && strcmp (mips16_opcodes
[i
].name
, name
) == 0);
939 /* We add all the general register names to the symbol table. This
940 helps us detect invalid uses of them. */
941 for (i
= 0; i
< 32; i
++)
945 sprintf (buf
, "$%d", i
);
946 symbol_table_insert (symbol_new (buf
, reg_section
, i
,
947 &zero_address_frag
));
949 symbol_table_insert (symbol_new ("$fp", reg_section
, FP
,
950 &zero_address_frag
));
951 symbol_table_insert (symbol_new ("$sp", reg_section
, SP
,
952 &zero_address_frag
));
953 symbol_table_insert (symbol_new ("$gp", reg_section
, GP
,
954 &zero_address_frag
));
955 symbol_table_insert (symbol_new ("$at", reg_section
, AT
,
956 &zero_address_frag
));
957 symbol_table_insert (symbol_new ("$kt0", reg_section
, KT0
,
958 &zero_address_frag
));
959 symbol_table_insert (symbol_new ("$kt1", reg_section
, KT1
,
960 &zero_address_frag
));
961 symbol_table_insert (symbol_new ("$pc", reg_section
, -1,
962 &zero_address_frag
));
964 mips_no_prev_insn ();
972 /* set the default alignment for the text section (2**2) */
973 record_alignment (text_section
, 2);
975 if (USE_GLOBAL_POINTER_OPT
)
976 bfd_set_gp_size (stdoutput
, g_switch_value
);
978 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
980 /* On a native system, sections must be aligned to 16 byte
981 boundaries. When configured for an embedded ELF target, we
983 if (strcmp (TARGET_OS
, "elf") != 0)
985 (void) bfd_set_section_alignment (stdoutput
, text_section
, 4);
986 (void) bfd_set_section_alignment (stdoutput
, data_section
, 4);
987 (void) bfd_set_section_alignment (stdoutput
, bss_section
, 4);
990 /* Create a .reginfo section for register masks and a .mdebug
991 section for debugging information. */
1001 /* The ABI says this section should be loaded so that the
1002 running program can access it. However, we don't load it
1003 if we are configured for an embedded target */
1004 flags
= SEC_READONLY
| SEC_DATA
;
1005 if (strcmp (TARGET_OS
, "elf") != 0)
1006 flags
|= SEC_ALLOC
| SEC_LOAD
;
1010 sec
= subseg_new (".reginfo", (subsegT
) 0);
1013 (void) bfd_set_section_flags (stdoutput
, sec
, flags
);
1014 (void) bfd_set_section_alignment (stdoutput
, sec
, 2);
1017 mips_regmask_frag
= frag_more (sizeof (Elf32_External_RegInfo
));
1022 /* The 64-bit ABI uses a .MIPS.options section rather than
1023 .reginfo section. */
1024 sec
= subseg_new (".MIPS.options", (subsegT
) 0);
1025 (void) bfd_set_section_flags (stdoutput
, sec
, flags
);
1026 (void) bfd_set_section_alignment (stdoutput
, sec
, 3);
1029 /* Set up the option header. */
1031 Elf_Internal_Options opthdr
;
1034 opthdr
.kind
= ODK_REGINFO
;
1035 opthdr
.size
= (sizeof (Elf_External_Options
)
1036 + sizeof (Elf64_External_RegInfo
));
1039 f
= frag_more (sizeof (Elf_External_Options
));
1040 bfd_mips_elf_swap_options_out (stdoutput
, &opthdr
,
1041 (Elf_External_Options
*) f
);
1043 mips_regmask_frag
= frag_more (sizeof (Elf64_External_RegInfo
));
1048 if (ECOFF_DEBUGGING
)
1050 sec
= subseg_new (".mdebug", (subsegT
) 0);
1051 (void) bfd_set_section_flags (stdoutput
, sec
,
1052 SEC_HAS_CONTENTS
| SEC_READONLY
);
1053 (void) bfd_set_section_alignment (stdoutput
, sec
, 2);
1056 subseg_set (seg
, subseg
);
1060 if (! ECOFF_DEBUGGING
)
1067 if (! ECOFF_DEBUGGING
)
1075 struct mips_cl_insn insn
;
1077 imm_expr
.X_op
= O_absent
;
1078 imm_reloc
= BFD_RELOC_UNUSED
;
1079 imm_unmatched_hi
= false;
1080 offset_expr
.X_op
= O_absent
;
1081 offset_reloc
= BFD_RELOC_UNUSED
;
1084 mips16_ip (str
, &insn
);
1086 mips_ip (str
, &insn
);
1090 as_bad ("%s `%s'", insn_error
, str
);
1094 if (insn
.insn_mo
->pinfo
== INSN_MACRO
)
1097 mips16_macro (&insn
);
1103 if (imm_expr
.X_op
!= O_absent
)
1104 append_insn ((char *) NULL
, &insn
, &imm_expr
, imm_reloc
,
1106 else if (offset_expr
.X_op
!= O_absent
)
1107 append_insn ((char *) NULL
, &insn
, &offset_expr
, offset_reloc
, false);
1109 append_insn ((char *) NULL
, &insn
, NULL
, BFD_RELOC_UNUSED
, false);
1113 /* See whether instruction IP reads register REG. CLASS is the type
1117 insn_uses_reg (ip
, reg
, class)
1118 struct mips_cl_insn
*ip
;
1120 enum mips_regclass
class;
1122 if (class == MIPS16_REG
)
1125 reg
= mips16_to_32_reg_map
[reg
];
1126 class = MIPS_GR_REG
;
1129 /* Don't report on general register 0, since it never changes. */
1130 if (class == MIPS_GR_REG
&& reg
== 0)
1133 if (class == MIPS_FP_REG
)
1136 /* If we are called with either $f0 or $f1, we must check $f0.
1137 This is not optimal, because it will introduce an unnecessary
1138 NOP between "lwc1 $f0" and "swc1 $f1". To fix this we would
1139 need to distinguish reading both $f0 and $f1 or just one of
1140 them. Note that we don't have to check the other way,
1141 because there is no instruction that sets both $f0 and $f1
1142 and requires a delay. */
1143 if ((ip
->insn_mo
->pinfo
& INSN_READ_FPR_S
)
1144 && (((ip
->insn_opcode
>> OP_SH_FS
) & OP_MASK_FS
)
1145 == (reg
&~ (unsigned) 1)))
1147 if ((ip
->insn_mo
->pinfo
& INSN_READ_FPR_T
)
1148 && (((ip
->insn_opcode
>> OP_SH_FT
) & OP_MASK_FT
)
1149 == (reg
&~ (unsigned) 1)))
1154 if ((ip
->insn_mo
->pinfo
& INSN_READ_GPR_S
)
1155 && ((ip
->insn_opcode
>> OP_SH_RS
) & OP_MASK_RS
) == reg
)
1157 if ((ip
->insn_mo
->pinfo
& INSN_READ_GPR_T
)
1158 && ((ip
->insn_opcode
>> OP_SH_RT
) & OP_MASK_RT
) == reg
)
1163 if ((ip
->insn_mo
->pinfo
& MIPS16_INSN_READ_X
)
1164 && ((ip
->insn_opcode
>> MIPS16OP_SH_RX
) & MIPS16OP_MASK_RX
) == reg
)
1166 if ((ip
->insn_mo
->pinfo
& MIPS16_INSN_READ_Y
)
1167 && ((ip
->insn_opcode
>> MIPS16OP_SH_RY
) & MIPS16OP_MASK_RY
) == reg
)
1169 if ((ip
->insn_mo
->pinfo
& MIPS16_INSN_READ_Z
)
1170 && ((ip
->insn_opcode
>> MIPS16OP_SH_MOVE32Z
)
1171 & MIPS16OP_MASK_MOVE32Z
) == reg
)
1173 if ((ip
->insn_mo
->pinfo
& MIPS16_INSN_READ_T
) && reg
== TREG
)
1175 if ((ip
->insn_mo
->pinfo
& MIPS16_INSN_READ_SP
) && reg
== SP
)
1177 if ((ip
->insn_mo
->pinfo
& MIPS16_INSN_READ_31
) && reg
== RA
)
1179 if ((ip
->insn_mo
->pinfo
& MIPS16_INSN_READ_GPR_X
)
1180 && ((ip
->insn_opcode
>> MIPS16OP_SH_REGR32
)
1181 & MIPS16OP_MASK_REGR32
) == reg
)
1188 /* This function returns true if modifying a register requires a
1192 reg_needs_delay (reg
)
1195 unsigned long prev_pinfo
;
1197 prev_pinfo
= prev_insn
.insn_mo
->pinfo
;
1198 if (! mips_noreorder
1200 && ((prev_pinfo
& INSN_LOAD_COPROC_DELAY
)
1202 && (prev_pinfo
& INSN_LOAD_MEMORY_DELAY
))))
1204 /* A load from a coprocessor or from memory. All load
1205 delays delay the use of general register rt for one
1206 instruction on the r3000. The r6000 and r4000 use
1208 know (prev_pinfo
& INSN_WRITE_GPR_T
);
1209 if (reg
== ((prev_insn
.insn_opcode
>> OP_SH_RT
) & OP_MASK_RT
))
1216 /* Output an instruction. PLACE is where to put the instruction; if
1217 it is NULL, this uses frag_more to get room. IP is the instruction
1218 information. ADDRESS_EXPR is an operand of the instruction to be
1219 used with RELOC_TYPE. */
1222 append_insn (place
, ip
, address_expr
, reloc_type
, unmatched_hi
)
1224 struct mips_cl_insn
*ip
;
1225 expressionS
*address_expr
;
1226 bfd_reloc_code_real_type reloc_type
;
1227 boolean unmatched_hi
;
1229 register unsigned long prev_pinfo
, pinfo
;
1234 /* Mark instruction labels in mips16 mode. This permits the linker
1235 to handle them specially, such as generating jalx instructions
1236 when needed. We also make them odd for the duration of the
1237 assembly, in order to generate the right sort of code. We will
1238 make them even in the adjust_symtab routine, while leaving them
1239 marked. This is convenient for the debugger and the
1240 disassembler. The linker knows to make them odd again. */
1243 struct insn_label_list
*l
;
1245 for (l
= insn_labels
; l
!= NULL
; l
= l
->next
)
1248 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1249 S_SET_OTHER (l
->label
, STO_MIPS16
);
1251 ++l
->label
->sy_value
.X_add_number
;
1255 prev_pinfo
= prev_insn
.insn_mo
->pinfo
;
1256 pinfo
= ip
->insn_mo
->pinfo
;
1258 if (place
== NULL
&& ! mips_noreorder
)
1260 /* If the previous insn required any delay slots, see if we need
1261 to insert a NOP or two. There are eight kinds of possible
1262 hazards, of which an instruction can have at most one type.
1263 (1) a load from memory delay
1264 (2) a load from a coprocessor delay
1265 (3) an unconditional branch delay
1266 (4) a conditional branch delay
1267 (5) a move to coprocessor register delay
1268 (6) a load coprocessor register from memory delay
1269 (7) a coprocessor condition code delay
1270 (8) a HI/LO special register delay
1272 There are a lot of optimizations we could do that we don't.
1273 In particular, we do not, in general, reorder instructions.
1274 If you use gcc with optimization, it will reorder
1275 instructions and generally do much more optimization then we
1276 do here; repeating all that work in the assembler would only
1277 benefit hand written assembly code, and does not seem worth
1280 /* This is how a NOP is emitted. */
1281 #define emit_nop() \
1283 ? md_number_to_chars (frag_more (2), 0x6500, 2) \
1284 : md_number_to_chars (frag_more (4), 0, 4))
1286 /* The previous insn might require a delay slot, depending upon
1287 the contents of the current insn. */
1290 && (((prev_pinfo
& INSN_LOAD_COPROC_DELAY
)
1291 && ! cop_interlocks
)
1293 && (prev_pinfo
& INSN_LOAD_MEMORY_DELAY
))))
1295 /* A load from a coprocessor or from memory. All load
1296 delays delay the use of general register rt for one
1297 instruction on the r3000. The r6000 and r4000 use
1299 know (prev_pinfo
& INSN_WRITE_GPR_T
);
1300 if (mips_optimize
== 0
1301 || insn_uses_reg (ip
,
1302 ((prev_insn
.insn_opcode
>> OP_SH_RT
)
1309 && (((prev_pinfo
& INSN_COPROC_MOVE_DELAY
)
1310 && ! cop_interlocks
)
1312 && (prev_pinfo
& INSN_COPROC_MEMORY_DELAY
))))
1314 /* A generic coprocessor delay. The previous instruction
1315 modified a coprocessor general or control register. If
1316 it modified a control register, we need to avoid any
1317 coprocessor instruction (this is probably not always
1318 required, but it sometimes is). If it modified a general
1319 register, we avoid using that register.
1321 On the r6000 and r4000 loading a coprocessor register
1322 from memory is interlocked, and does not require a delay.
1324 This case is not handled very well. There is no special
1325 knowledge of CP0 handling, and the coprocessors other
1326 than the floating point unit are not distinguished at
1328 if (prev_pinfo
& INSN_WRITE_FPR_T
)
1330 if (mips_optimize
== 0
1331 || insn_uses_reg (ip
,
1332 ((prev_insn
.insn_opcode
>> OP_SH_FT
)
1337 else if (prev_pinfo
& INSN_WRITE_FPR_S
)
1339 if (mips_optimize
== 0
1340 || insn_uses_reg (ip
,
1341 ((prev_insn
.insn_opcode
>> OP_SH_FS
)
1348 /* We don't know exactly what the previous instruction
1349 does. If the current instruction uses a coprocessor
1350 register, we must insert a NOP. If previous
1351 instruction may set the condition codes, and the
1352 current instruction uses them, we must insert two
1354 if (mips_optimize
== 0
1355 || ((prev_pinfo
& INSN_WRITE_COND_CODE
)
1356 && (pinfo
& INSN_READ_COND_CODE
)))
1358 else if (pinfo
& INSN_COP
)
1364 && (prev_pinfo
& INSN_WRITE_COND_CODE
)
1365 && ! cop_interlocks
)
1367 /* The previous instruction sets the coprocessor condition
1368 codes, but does not require a general coprocessor delay
1369 (this means it is a floating point comparison
1370 instruction). If this instruction uses the condition
1371 codes, we need to insert a single NOP. */
1372 if (mips_optimize
== 0
1373 || (pinfo
& INSN_READ_COND_CODE
))
1376 else if (prev_pinfo
& INSN_READ_LO
)
1378 /* The previous instruction reads the LO register; if the
1379 current instruction writes to the LO register, we must
1380 insert two NOPS. Some newer processors have interlocks. */
1382 && (mips_optimize
== 0
1383 || (pinfo
& INSN_WRITE_LO
)))
1386 else if (prev_insn
.insn_mo
->pinfo
& INSN_READ_HI
)
1388 /* The previous instruction reads the HI register; if the
1389 current instruction writes to the HI register, we must
1390 insert a NOP. Some newer processors have interlocks. */
1392 && (mips_optimize
== 0
1393 || (pinfo
& INSN_WRITE_HI
)))
1397 /* There are two cases which require two intervening
1398 instructions: 1) setting the condition codes using a move to
1399 coprocessor instruction which requires a general coprocessor
1400 delay and then reading the condition codes 2) reading the HI
1401 or LO register and then writing to it (except on processors
1402 which have interlocks). If we are not already emitting a NOP
1403 instruction, we must check for these cases compared to the
1404 instruction previous to the previous instruction. */
1408 && (prev_prev_insn
.insn_mo
->pinfo
& INSN_COPROC_MOVE_DELAY
)
1409 && (prev_prev_insn
.insn_mo
->pinfo
& INSN_WRITE_COND_CODE
)
1410 && (pinfo
& INSN_READ_COND_CODE
)
1411 && ! cop_interlocks
)
1412 || ((prev_prev_insn
.insn_mo
->pinfo
& INSN_READ_LO
)
1413 && (pinfo
& INSN_WRITE_LO
)
1415 || ((prev_prev_insn
.insn_mo
->pinfo
& INSN_READ_HI
)
1416 && (pinfo
& INSN_WRITE_HI
)
1420 /* If we are being given a nop instruction, don't bother with
1421 one of the nops we would otherwise output. This will only
1422 happen when a nop instruction is used with mips_optimize set
1424 if (nops
> 0 && ip
->insn_opcode
== (mips16
? 0x6500 : 0))
1427 /* Now emit the right number of NOP instructions. */
1431 unsigned long old_frag_offset
;
1433 struct insn_label_list
*l
;
1435 old_frag
= frag_now
;
1436 old_frag_offset
= frag_now_fix ();
1438 for (i
= 0; i
< nops
; i
++)
1443 listing_prev_line ();
1444 /* We may be at the start of a variant frag. In case we
1445 are, make sure there is enough space for the frag
1446 after the frags created by listing_prev_line. The
1447 argument to frag_grow here must be at least as large
1448 as the argument to all other calls to frag_grow in
1449 this file. We don't have to worry about being in the
1450 middle of a variant frag, because the variants insert
1451 all needed nop instructions themselves. */
1455 for (l
= insn_labels
; l
!= NULL
; l
= l
->next
)
1457 assert (S_GET_SEGMENT (l
->label
) == now_seg
);
1458 l
->label
->sy_frag
= frag_now
;
1459 S_SET_VALUE (l
->label
, (valueT
) frag_now_fix ());
1460 /* mips16 text labels are stored as odd. */
1462 ++l
->label
->sy_value
.X_add_number
;
1465 #ifndef NO_ECOFF_DEBUGGING
1466 if (ECOFF_DEBUGGING
)
1467 ecoff_fix_loc (old_frag
, old_frag_offset
);
1472 if (reloc_type
> BFD_RELOC_UNUSED
)
1474 /* We need to set up a variant frag. */
1475 assert (mips16
&& address_expr
!= NULL
);
1476 f
= frag_var (rs_machine_dependent
, 4, 0,
1477 RELAX_MIPS16_ENCODE (reloc_type
- BFD_RELOC_UNUSED
,
1478 mips16_small
, mips16_ext
,
1480 & INSN_UNCOND_BRANCH_DELAY
),
1481 (prev_insn_reloc_type
1482 == BFD_RELOC_MIPS16_JMP
)),
1483 make_expr_symbol (address_expr
), (long) 0,
1486 else if (place
!= NULL
)
1488 else if (mips16
&& ! ip
->use_extend
&& reloc_type
!= BFD_RELOC_MIPS16_JMP
)
1490 /* Make sure there is enough room to swap this instruction with
1491 a following jump instruction. */
1499 && (prev_pinfo
& INSN_UNCOND_BRANCH_DELAY
) != 0)
1500 as_warn ("extended instruction in delay slot");
1506 if (address_expr
!= NULL
&& reloc_type
< BFD_RELOC_UNUSED
)
1508 if (address_expr
->X_op
== O_constant
)
1513 ip
->insn_opcode
|= address_expr
->X_add_number
;
1516 case BFD_RELOC_LO16
:
1517 ip
->insn_opcode
|= address_expr
->X_add_number
& 0xffff;
1520 case BFD_RELOC_MIPS_JMP
:
1521 if ((address_expr
->X_add_number
& 3) != 0)
1522 as_bad ("jump to misaligned address (0x%lx)",
1523 (unsigned long) address_expr
->X_add_number
);
1524 ip
->insn_opcode
|= (address_expr
->X_add_number
>> 2) & 0x3ffffff;
1527 case BFD_RELOC_MIPS16_JMP
:
1528 if ((address_expr
->X_add_number
& 3) != 0)
1529 as_bad ("jump to misaligned address (0x%lx)",
1530 (unsigned long) address_expr
->X_add_number
);
1532 (((address_expr
->X_add_number
& 0x7c0000) << 3)
1533 | ((address_expr
->X_add_number
& 0xf800000) >> 7)
1534 | ((address_expr
->X_add_number
& 0x3fffc) >> 2));
1537 case BFD_RELOC_16_PCREL_S2
:
1547 /* Don't generate a reloc if we are writing into a variant
1551 fixp
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4,
1553 reloc_type
== BFD_RELOC_16_PCREL_S2
,
1557 struct mips_hi_fixup
*hi_fixup
;
1559 assert (reloc_type
== BFD_RELOC_HI16_S
);
1560 hi_fixup
= ((struct mips_hi_fixup
*)
1561 xmalloc (sizeof (struct mips_hi_fixup
)));
1562 hi_fixup
->fixp
= fixp
;
1563 hi_fixup
->seg
= now_seg
;
1564 hi_fixup
->next
= mips_hi_fixup_list
;
1565 mips_hi_fixup_list
= hi_fixup
;
1572 md_number_to_chars (f
, ip
->insn_opcode
, 4);
1573 else if (reloc_type
== BFD_RELOC_MIPS16_JMP
)
1575 md_number_to_chars (f
, ip
->insn_opcode
>> 16, 2);
1576 md_number_to_chars (f
+ 2, ip
->insn_opcode
& 0xffff, 2);
1582 md_number_to_chars (f
, 0xf000 | ip
->extend
, 2);
1585 md_number_to_chars (f
, ip
->insn_opcode
, 2);
1588 /* Update the register mask information. */
1591 if (pinfo
& INSN_WRITE_GPR_D
)
1592 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> OP_SH_RD
) & OP_MASK_RD
);
1593 if ((pinfo
& (INSN_WRITE_GPR_T
| INSN_READ_GPR_T
)) != 0)
1594 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> OP_SH_RT
) & OP_MASK_RT
);
1595 if (pinfo
& INSN_READ_GPR_S
)
1596 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> OP_SH_RS
) & OP_MASK_RS
);
1597 if (pinfo
& INSN_WRITE_GPR_31
)
1598 mips_gprmask
|= 1 << 31;
1599 if (pinfo
& INSN_WRITE_FPR_D
)
1600 mips_cprmask
[1] |= 1 << ((ip
->insn_opcode
>> OP_SH_FD
) & OP_MASK_FD
);
1601 if ((pinfo
& (INSN_WRITE_FPR_S
| INSN_READ_FPR_S
)) != 0)
1602 mips_cprmask
[1] |= 1 << ((ip
->insn_opcode
>> OP_SH_FS
) & OP_MASK_FS
);
1603 if ((pinfo
& (INSN_WRITE_FPR_T
| INSN_READ_FPR_T
)) != 0)
1604 mips_cprmask
[1] |= 1 << ((ip
->insn_opcode
>> OP_SH_FT
) & OP_MASK_FT
);
1605 if ((pinfo
& INSN_READ_FPR_R
) != 0)
1606 mips_cprmask
[1] |= 1 << ((ip
->insn_opcode
>> OP_SH_FR
) & OP_MASK_FR
);
1607 if (pinfo
& INSN_COP
)
1609 /* We don't keep enough information to sort these cases out. */
1611 /* Never set the bit for $0, which is always zero. */
1612 mips_gprmask
&=~ 1 << 0;
1616 if (pinfo
& (MIPS16_INSN_WRITE_X
| MIPS16_INSN_READ_X
))
1617 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> MIPS16OP_SH_RX
)
1618 & MIPS16OP_MASK_RX
);
1619 if (pinfo
& (MIPS16_INSN_WRITE_Y
| MIPS16_INSN_READ_Y
))
1620 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> MIPS16OP_SH_RY
)
1621 & MIPS16OP_MASK_RY
);
1622 if (pinfo
& MIPS16_INSN_WRITE_Z
)
1623 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> MIPS16OP_SH_RZ
)
1624 & MIPS16OP_MASK_RZ
);
1625 if (pinfo
& (MIPS16_INSN_WRITE_T
| MIPS16_INSN_READ_T
))
1626 mips_gprmask
|= 1 << TREG
;
1627 if (pinfo
& (MIPS16_INSN_WRITE_SP
| MIPS16_INSN_READ_SP
))
1628 mips_gprmask
|= 1 << SP
;
1629 if (pinfo
& (MIPS16_INSN_WRITE_31
| MIPS16_INSN_READ_31
))
1630 mips_gprmask
|= 1 << RA
;
1631 if (pinfo
& MIPS16_INSN_WRITE_GPR_Y
)
1632 mips_gprmask
|= 1 << MIPS16OP_EXTRACT_REG32R (ip
->insn_opcode
);
1633 if (pinfo
& MIPS16_INSN_READ_Z
)
1634 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> MIPS16OP_SH_MOVE32Z
)
1635 & MIPS16OP_MASK_MOVE32Z
);
1636 if (pinfo
& MIPS16_INSN_READ_GPR_X
)
1637 mips_gprmask
|= 1 << ((ip
->insn_opcode
>> MIPS16OP_SH_REGR32
)
1638 & MIPS16OP_MASK_REGR32
);
1641 if (place
== NULL
&& ! mips_noreorder
)
1643 /* Filling the branch delay slot is more complex. We try to
1644 switch the branch with the previous instruction, which we can
1645 do if the previous instruction does not set up a condition
1646 that the branch tests and if the branch is not itself the
1647 target of any branch. */
1648 if ((pinfo
& INSN_UNCOND_BRANCH_DELAY
)
1649 || (pinfo
& INSN_COND_BRANCH_DELAY
))
1651 if (mips_optimize
< 2
1652 /* If we have seen .set volatile or .set nomove, don't
1655 /* If we had to emit any NOP instructions, then we
1656 already know we can not swap. */
1658 /* If we don't even know the previous insn, we can not
1660 || ! prev_insn_valid
1661 /* If the previous insn is already in a branch delay
1662 slot, then we can not swap. */
1663 || prev_insn_is_delay_slot
1664 /* If the previous previous insn was in a .set
1665 noreorder, we can't swap. Actually, the MIPS
1666 assembler will swap in this situation. However, gcc
1667 configured -with-gnu-as will generate code like
1673 in which we can not swap the bne and INSN. If gcc is
1674 not configured -with-gnu-as, it does not output the
1675 .set pseudo-ops. We don't have to check
1676 prev_insn_unreordered, because prev_insn_valid will
1677 be 0 in that case. We don't want to use
1678 prev_prev_insn_valid, because we do want to be able
1679 to swap at the start of a function. */
1680 || prev_prev_insn_unreordered
1681 /* If the branch is itself the target of a branch, we
1682 can not swap. We cheat on this; all we check for is
1683 whether there is a label on this instruction. If
1684 there are any branches to anything other than a
1685 label, users must use .set noreorder. */
1686 || insn_labels
!= NULL
1687 /* If the previous instruction is in a variant frag, we
1688 can not do the swap. This does not apply to the
1689 mips16, which uses variant frags for different
1692 && prev_insn_frag
->fr_type
== rs_machine_dependent
)
1693 /* If the branch reads the condition codes, we don't
1694 even try to swap, because in the sequence
1699 we can not swap, and I don't feel like handling that
1703 && (pinfo
& INSN_READ_COND_CODE
))
1704 /* We can not swap with an instruction that requires a
1705 delay slot, becase the target of the branch might
1706 interfere with that instruction. */
1710 & (INSN_LOAD_COPROC_DELAY
1711 | INSN_COPROC_MOVE_DELAY
1712 | INSN_WRITE_COND_CODE
)))
1720 & (INSN_LOAD_MEMORY_DELAY
1721 | INSN_COPROC_MEMORY_DELAY
)))
1722 /* We can not swap with a branch instruction. */
1724 & (INSN_UNCOND_BRANCH_DELAY
1725 | INSN_COND_BRANCH_DELAY
1726 | INSN_COND_BRANCH_LIKELY
))
1727 /* We do not swap with a trap instruction, since it
1728 complicates trap handlers to have the trap
1729 instruction be in a delay slot. */
1730 || (prev_pinfo
& INSN_TRAP
)
1731 /* If the branch reads a register that the previous
1732 instruction sets, we can not swap. */
1734 && (prev_pinfo
& INSN_WRITE_GPR_T
)
1735 && insn_uses_reg (ip
,
1736 ((prev_insn
.insn_opcode
>> OP_SH_RT
)
1740 && (prev_pinfo
& INSN_WRITE_GPR_D
)
1741 && insn_uses_reg (ip
,
1742 ((prev_insn
.insn_opcode
>> OP_SH_RD
)
1746 && (((prev_pinfo
& MIPS16_INSN_WRITE_X
)
1747 && insn_uses_reg (ip
,
1748 ((prev_insn
.insn_opcode
1750 & MIPS16OP_MASK_RX
),
1752 || ((prev_pinfo
& MIPS16_INSN_WRITE_Y
)
1753 && insn_uses_reg (ip
,
1754 ((prev_insn
.insn_opcode
1756 & MIPS16OP_MASK_RY
),
1758 || ((prev_pinfo
& MIPS16_INSN_WRITE_Z
)
1759 && insn_uses_reg (ip
,
1760 ((prev_insn
.insn_opcode
1762 & MIPS16OP_MASK_RZ
),
1764 || ((prev_pinfo
& MIPS16_INSN_WRITE_T
)
1765 && insn_uses_reg (ip
, TREG
, MIPS_GR_REG
))
1766 || ((prev_pinfo
& MIPS16_INSN_WRITE_31
)
1767 && insn_uses_reg (ip
, RA
, MIPS_GR_REG
))
1768 || ((prev_pinfo
& MIPS16_INSN_WRITE_GPR_Y
)
1769 && insn_uses_reg (ip
,
1770 MIPS16OP_EXTRACT_REG32R (prev_insn
.
1773 /* If the branch writes a register that the previous
1774 instruction sets, we can not swap (we know that
1775 branches write only to RD or to $31). */
1777 && (prev_pinfo
& INSN_WRITE_GPR_T
)
1778 && (((pinfo
& INSN_WRITE_GPR_D
)
1779 && (((prev_insn
.insn_opcode
>> OP_SH_RT
) & OP_MASK_RT
)
1780 == ((ip
->insn_opcode
>> OP_SH_RD
) & OP_MASK_RD
)))
1781 || ((pinfo
& INSN_WRITE_GPR_31
)
1782 && (((prev_insn
.insn_opcode
>> OP_SH_RT
)
1786 && (prev_pinfo
& INSN_WRITE_GPR_D
)
1787 && (((pinfo
& INSN_WRITE_GPR_D
)
1788 && (((prev_insn
.insn_opcode
>> OP_SH_RD
) & OP_MASK_RD
)
1789 == ((ip
->insn_opcode
>> OP_SH_RD
) & OP_MASK_RD
)))
1790 || ((pinfo
& INSN_WRITE_GPR_31
)
1791 && (((prev_insn
.insn_opcode
>> OP_SH_RD
)
1795 && (pinfo
& MIPS16_INSN_WRITE_31
)
1796 && ((prev_pinfo
& MIPS16_INSN_WRITE_31
)
1797 || ((prev_pinfo
& MIPS16_INSN_WRITE_GPR_Y
)
1798 && (MIPS16OP_EXTRACT_REG32R (prev_insn
.insn_opcode
)
1800 /* If the branch writes a register that the previous
1801 instruction reads, we can not swap (we know that
1802 branches only write to RD or to $31). */
1804 && (pinfo
& INSN_WRITE_GPR_D
)
1805 && insn_uses_reg (&prev_insn
,
1806 ((ip
->insn_opcode
>> OP_SH_RD
)
1810 && (pinfo
& INSN_WRITE_GPR_31
)
1811 && insn_uses_reg (&prev_insn
, 31, MIPS_GR_REG
))
1813 && (pinfo
& MIPS16_INSN_WRITE_31
)
1814 && insn_uses_reg (&prev_insn
, RA
, MIPS_GR_REG
))
1815 /* If we are generating embedded PIC code, the branch
1816 might be expanded into a sequence which uses $at, so
1817 we can't swap with an instruction which reads it. */
1818 || (mips_pic
== EMBEDDED_PIC
1819 && insn_uses_reg (&prev_insn
, AT
, MIPS_GR_REG
))
1820 /* If the previous previous instruction has a load
1821 delay, and sets a register that the branch reads, we
1825 && ((prev_prev_insn
.insn_mo
->pinfo
& INSN_LOAD_COPROC_DELAY
)
1827 && (prev_prev_insn
.insn_mo
->pinfo
1828 & INSN_LOAD_MEMORY_DELAY
)))
1829 && insn_uses_reg (ip
,
1830 ((prev_prev_insn
.insn_opcode
>> OP_SH_RT
)
1833 /* If one instruction sets a condition code and the
1834 other one uses a condition code, we can not swap. */
1835 || ((pinfo
& INSN_READ_COND_CODE
)
1836 && (prev_pinfo
& INSN_WRITE_COND_CODE
))
1837 || ((pinfo
& INSN_WRITE_COND_CODE
)
1838 && (prev_pinfo
& INSN_READ_COND_CODE
))
1839 /* If the previous instruction uses the PC, we can not
1842 && (prev_pinfo
& MIPS16_INSN_READ_PC
))
1843 /* If the previous instruction was extended, we can not
1845 || (mips16
&& prev_insn_extended
)
1846 /* If the previous instruction had a fixup in mips16
1847 mode, we can not swap. This normally means that the
1848 previous instruction was a 4 byte branch anyhow. */
1849 || (mips16
&& prev_insn_fixp
))
1851 /* We could do even better for unconditional branches to
1852 portions of this object file; we could pick up the
1853 instruction at the destination, put it in the delay
1854 slot, and bump the destination address. */
1856 /* Update the previous insn information. */
1857 prev_prev_insn
= *ip
;
1858 prev_insn
.insn_mo
= &dummy_opcode
;
1862 /* It looks like we can actually do the swap. */
1868 prev_f
= prev_insn_frag
->fr_literal
+ prev_insn_where
;
1869 memcpy (temp
, prev_f
, 4);
1870 memcpy (prev_f
, f
, 4);
1871 memcpy (f
, temp
, 4);
1874 prev_insn_fixp
->fx_frag
= frag_now
;
1875 prev_insn_fixp
->fx_where
= f
- frag_now
->fr_literal
;
1879 fixp
->fx_frag
= prev_insn_frag
;
1880 fixp
->fx_where
= prev_insn_where
;
1883 else if (reloc_type
> BFD_RELOC_UNUSED
)
1888 /* We are in mips16 mode, and we have just created a
1889 variant frag. We need to extract the old
1890 instruction from the end of the previous frag,
1891 and add it to a new frag. */
1892 prev_f
= prev_insn_frag
->fr_literal
+ prev_insn_where
;
1893 memcpy (temp
, prev_f
, 2);
1894 prev_insn_frag
->fr_fix
-= 2;
1895 if (prev_insn_frag
->fr_type
== rs_machine_dependent
)
1897 assert (prev_insn_where
== prev_insn_frag
->fr_fix
);
1898 memcpy (prev_f
, prev_f
+ 2, 2);
1900 memcpy (frag_more (2), temp
, 2);
1907 assert (prev_insn_fixp
== NULL
);
1908 prev_f
= prev_insn_frag
->fr_literal
+ prev_insn_where
;
1909 memcpy (temp
, prev_f
, 2);
1910 memcpy (prev_f
, f
, 2);
1911 if (reloc_type
!= BFD_RELOC_MIPS16_JMP
)
1912 memcpy (f
, temp
, 2);
1915 memcpy (f
, f
+ 2, 2);
1916 memcpy (f
+ 2, temp
, 2);
1920 fixp
->fx_frag
= prev_insn_frag
;
1921 fixp
->fx_where
= prev_insn_where
;
1925 /* Update the previous insn information; leave prev_insn
1927 prev_prev_insn
= *ip
;
1929 prev_insn_is_delay_slot
= 1;
1931 /* If that was an unconditional branch, forget the previous
1932 insn information. */
1933 if (pinfo
& INSN_UNCOND_BRANCH_DELAY
)
1935 prev_prev_insn
.insn_mo
= &dummy_opcode
;
1936 prev_insn
.insn_mo
= &dummy_opcode
;
1939 prev_insn_fixp
= NULL
;
1940 prev_insn_reloc_type
= BFD_RELOC_UNUSED
;
1941 prev_insn_extended
= 0;
1943 else if (pinfo
& INSN_COND_BRANCH_LIKELY
)
1945 /* We don't yet optimize a branch likely. What we should do
1946 is look at the target, copy the instruction found there
1947 into the delay slot, and increment the branch to jump to
1948 the next instruction. */
1950 /* Update the previous insn information. */
1951 prev_prev_insn
= *ip
;
1952 prev_insn
.insn_mo
= &dummy_opcode
;
1953 prev_insn_fixp
= NULL
;
1954 prev_insn_reloc_type
= BFD_RELOC_UNUSED
;
1955 prev_insn_extended
= 0;
1959 /* Update the previous insn information. */
1961 prev_prev_insn
.insn_mo
= &dummy_opcode
;
1963 prev_prev_insn
= prev_insn
;
1966 /* Any time we see a branch, we always fill the delay slot
1967 immediately; since this insn is not a branch, we know it
1968 is not in a delay slot. */
1969 prev_insn_is_delay_slot
= 0;
1971 prev_insn_fixp
= fixp
;
1972 prev_insn_reloc_type
= reloc_type
;
1974 prev_insn_extended
= (ip
->use_extend
1975 || reloc_type
> BFD_RELOC_UNUSED
);
1978 prev_prev_insn_unreordered
= prev_insn_unreordered
;
1979 prev_insn_unreordered
= 0;
1980 prev_insn_frag
= frag_now
;
1981 prev_insn_where
= f
- frag_now
->fr_literal
;
1982 prev_insn_valid
= 1;
1984 else if (place
== NULL
)
1986 /* We need to record a bit of information even when we are not
1987 reordering, in order to determine the base address for mips16
1988 PC relative relocs. */
1990 prev_insn_reloc_type
= reloc_type
;
1991 prev_insn_valid
= 1;
1994 /* We just output an insn, so the next one doesn't have a label. */
1995 mips_clear_insn_labels ();
1998 /* This function forgets that there was any previous instruction or
2002 mips_no_prev_insn ()
2004 prev_insn
.insn_mo
= &dummy_opcode
;
2005 prev_prev_insn
.insn_mo
= &dummy_opcode
;
2006 prev_insn_valid
= 0;
2007 prev_insn_is_delay_slot
= 0;
2008 prev_insn_unreordered
= 0;
2009 prev_insn_extended
= 0;
2010 prev_insn_reloc_type
= BFD_RELOC_UNUSED
;
2011 prev_prev_insn_unreordered
= 0;
2012 mips_clear_insn_labels ();
2015 /* This function must be called whenever we turn on noreorder or emit
2016 something other than instructions. It inserts any NOPS which might
2017 be needed by the previous instruction, and clears the information
2018 kept for the previous instructions. The INSNS parameter is true if
2019 instructions are to follow. */
2022 mips_emit_delays (insns
)
2025 if (! mips_noreorder
)
2032 && (! cop_interlocks
2033 && (prev_insn
.insn_mo
->pinfo
2034 & (INSN_LOAD_COPROC_DELAY
2035 | INSN_COPROC_MOVE_DELAY
2036 | INSN_WRITE_COND_CODE
))))
2038 && (prev_insn
.insn_mo
->pinfo
2043 && (prev_insn
.insn_mo
->pinfo
2044 & (INSN_LOAD_MEMORY_DELAY
2045 | INSN_COPROC_MEMORY_DELAY
))))
2050 && (! cop_interlocks
2051 && prev_insn
.insn_mo
->pinfo
& INSN_WRITE_COND_CODE
))
2053 && ((prev_insn
.insn_mo
->pinfo
& INSN_READ_HI
)
2054 || (prev_insn
.insn_mo
->pinfo
& INSN_READ_LO
))))
2059 && (! cop_interlocks
2060 && prev_prev_insn
.insn_mo
->pinfo
& INSN_WRITE_COND_CODE
))
2062 && ((prev_prev_insn
.insn_mo
->pinfo
& INSN_READ_HI
)
2063 || (prev_prev_insn
.insn_mo
->pinfo
& INSN_READ_LO
))))
2067 struct insn_label_list
*l
;
2070 for (l
= insn_labels
; l
!= NULL
; l
= l
->next
)
2072 assert (S_GET_SEGMENT (l
->label
) == now_seg
);
2073 l
->label
->sy_frag
= frag_now
;
2074 S_SET_VALUE (l
->label
, (valueT
) frag_now_fix ());
2075 /* mips16 text labels are stored as odd. */
2077 ++l
->label
->sy_value
.X_add_number
;
2082 /* Mark instruction labels in mips16 mode. This permits the linker
2083 to handle them specially, such as generating jalx instructions
2084 when needed. We also make them odd for the duration of the
2085 assembly, in order to generate the right sort of code. We will
2086 make them even in the adjust_symtab routine, while leaving them
2087 marked. This is convenient for the debugger and the
2088 disassembler. The linker knows to make them odd again. */
2089 if (mips16
&& insns
)
2091 struct insn_label_list
*l
;
2093 for (l
= insn_labels
; l
!= NULL
; l
= l
->next
)
2096 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2097 S_SET_OTHER (l
->label
, STO_MIPS16
);
2099 if ((l
->label
->sy_value
.X_add_number
& 1) == 0)
2100 ++l
->label
->sy_value
.X_add_number
;
2104 mips_no_prev_insn ();
2107 /* Build an instruction created by a macro expansion. This is passed
2108 a pointer to the count of instructions created so far, an
2109 expression, the name of the instruction to build, an operand format
2110 string, and corresponding arguments. */
2114 macro_build (char *place
,
2122 macro_build (place
, counter
, ep
, name
, fmt
, va_alist
)
2131 struct mips_cl_insn insn
;
2132 bfd_reloc_code_real_type r
;
2136 va_start (args
, fmt
);
2142 * If the macro is about to expand into a second instruction,
2143 * print a warning if needed. We need to pass ip as a parameter
2144 * to generate a better warning message here...
2146 if (mips_warn_about_macros
&& place
== NULL
&& *counter
== 1)
2147 as_warn ("Macro instruction expanded into multiple instructions");
2150 *counter
+= 1; /* bump instruction counter */
2154 mips16_macro_build (place
, counter
, ep
, name
, fmt
, args
);
2159 r
= BFD_RELOC_UNUSED
;
2160 insn
.insn_mo
= (struct mips_opcode
*) hash_find (op_hash
, name
);
2161 assert (insn
.insn_mo
);
2162 assert (strcmp (name
, insn
.insn_mo
->name
) == 0);
2164 while (strcmp (fmt
, insn
.insn_mo
->args
) != 0
2165 || insn
.insn_mo
->pinfo
== INSN_MACRO
2166 || ((insn
.insn_mo
->pinfo
& INSN_ISA
) == INSN_ISA2
2168 || ((insn
.insn_mo
->pinfo
& INSN_ISA
) == INSN_ISA3
2170 || ((insn
.insn_mo
->pinfo
& INSN_ISA
) == INSN_ISA4
2172 || ((insn
.insn_mo
->pinfo
& INSN_ISA
) == INSN_4650
2174 || ((insn
.insn_mo
->pinfo
& INSN_ISA
) == INSN_4010
2176 || ((insn
.insn_mo
->pinfo
& INSN_ISA
) == INSN_4100
2178 /* start-sanitize-r5900 */
2179 || ((insn
.insn_mo
->pinfo
& INSN_ISA
) == INSN_5900
2181 /* end-sanitize-r5900 */
2185 assert (insn
.insn_mo
->name
);
2186 assert (strcmp (name
, insn
.insn_mo
->name
) == 0);
2188 insn
.insn_opcode
= insn
.insn_mo
->match
;
2204 insn
.insn_opcode
|= va_arg (args
, int) << 16;
2210 insn
.insn_opcode
|= va_arg (args
, int) << 16;
2215 insn
.insn_opcode
|= va_arg (args
, int) << 11;
2220 insn
.insn_opcode
|= va_arg (args
, int) << 11;
2227 insn
.insn_opcode
|= va_arg (args
, int) << 6;
2231 insn
.insn_opcode
|= va_arg (args
, int) << 6;
2235 insn
.insn_opcode
|= va_arg (args
, int) << 6;
2242 insn
.insn_opcode
|= va_arg (args
, int) << 21;
2248 r
= (bfd_reloc_code_real_type
) va_arg (args
, int);
2249 assert (r
== BFD_RELOC_MIPS_GPREL
2250 || r
== BFD_RELOC_MIPS_LITERAL
2251 || r
== BFD_RELOC_LO16
2252 || r
== BFD_RELOC_MIPS_GOT16
2253 || r
== BFD_RELOC_MIPS_CALL16
2254 || r
== BFD_RELOC_MIPS_GOT_LO16
2255 || r
== BFD_RELOC_MIPS_CALL_LO16
2256 || (ep
->X_op
== O_subtract
2257 && now_seg
== text_section
2258 && r
== BFD_RELOC_PCREL_LO16
));
2262 r
= (bfd_reloc_code_real_type
) va_arg (args
, int);
2264 && (ep
->X_op
== O_constant
2265 || (ep
->X_op
== O_symbol
2266 && (r
== BFD_RELOC_HI16_S
2267 || r
== BFD_RELOC_HI16
2268 || r
== BFD_RELOC_MIPS_GOT_HI16
2269 || r
== BFD_RELOC_MIPS_CALL_HI16
))
2270 || (ep
->X_op
== O_subtract
2271 && now_seg
== text_section
2272 && r
== BFD_RELOC_PCREL_HI16_S
)));
2273 if (ep
->X_op
== O_constant
)
2275 insn
.insn_opcode
|= (ep
->X_add_number
>> 16) & 0xffff;
2277 r
= BFD_RELOC_UNUSED
;
2282 assert (ep
!= NULL
);
2284 * This allows macro() to pass an immediate expression for
2285 * creating short branches without creating a symbol.
2286 * Note that the expression still might come from the assembly
2287 * input, in which case the value is not checked for range nor
2288 * is a relocation entry generated (yuck).
2290 if (ep
->X_op
== O_constant
)
2292 insn
.insn_opcode
|= (ep
->X_add_number
>> 2) & 0xffff;
2296 r
= BFD_RELOC_16_PCREL_S2
;
2300 assert (ep
!= NULL
);
2301 r
= BFD_RELOC_MIPS_JMP
;
2310 assert (r
== BFD_RELOC_UNUSED
? ep
== NULL
: ep
!= NULL
);
2312 append_insn (place
, &insn
, ep
, r
, false);
2316 mips16_macro_build (place
, counter
, ep
, name
, fmt
, args
)
2324 struct mips_cl_insn insn
;
2325 bfd_reloc_code_real_type r
;
2327 r
= BFD_RELOC_UNUSED
;
2328 insn
.insn_mo
= (struct mips_opcode
*) hash_find (mips16_op_hash
, name
);
2329 assert (insn
.insn_mo
);
2330 assert (strcmp (name
, insn
.insn_mo
->name
) == 0);
2332 while (strcmp (fmt
, insn
.insn_mo
->args
) != 0
2333 || insn
.insn_mo
->pinfo
== INSN_MACRO
)
2336 assert (insn
.insn_mo
->name
);
2337 assert (strcmp (name
, insn
.insn_mo
->name
) == 0);
2340 insn
.insn_opcode
= insn
.insn_mo
->match
;
2341 insn
.use_extend
= false;
2360 insn
.insn_opcode
|= va_arg (args
, int) << MIPS16OP_SH_RY
;
2365 insn
.insn_opcode
|= va_arg (args
, int) << MIPS16OP_SH_RX
;
2369 insn
.insn_opcode
|= va_arg (args
, int) << MIPS16OP_SH_RZ
;
2373 insn
.insn_opcode
|= va_arg (args
, int) << MIPS16OP_SH_MOVE32Z
;
2383 insn
.insn_opcode
|= va_arg (args
, int) << MIPS16OP_SH_REGR32
;
2390 regno
= va_arg (args
, int);
2391 regno
= ((regno
& 7) << 2) | ((regno
& 0x18) >> 3);
2392 insn
.insn_opcode
|= regno
<< MIPS16OP_SH_REG32R
;
2413 assert (ep
!= NULL
);
2415 if (ep
->X_op
!= O_constant
)
2416 r
= BFD_RELOC_UNUSED
+ c
;
2419 mips16_immed ((char *) NULL
, 0, c
, ep
->X_add_number
, false,
2420 false, false, &insn
.insn_opcode
,
2421 &insn
.use_extend
, &insn
.extend
);
2423 r
= BFD_RELOC_UNUSED
;
2429 insn
.insn_opcode
|= va_arg (args
, int) << MIPS16OP_SH_IMM6
;
2436 assert (r
== BFD_RELOC_UNUSED
? ep
== NULL
: ep
!= NULL
);
2438 append_insn (place
, &insn
, ep
, r
, false);
2442 * Generate a "lui" instruction.
2445 macro_build_lui (place
, counter
, ep
, regnum
)
2451 expressionS high_expr
;
2452 struct mips_cl_insn insn
;
2453 bfd_reloc_code_real_type r
;
2454 CONST
char *name
= "lui";
2455 CONST
char *fmt
= "t,u";
2463 high_expr
.X_op
= O_constant
;
2464 high_expr
.X_add_number
= ep
->X_add_number
;
2467 if (high_expr
.X_op
== O_constant
)
2469 /* we can compute the instruction now without a relocation entry */
2470 if (high_expr
.X_add_number
& 0x8000)
2471 high_expr
.X_add_number
+= 0x10000;
2472 high_expr
.X_add_number
=
2473 ((unsigned long) high_expr
.X_add_number
>> 16) & 0xffff;
2474 r
= BFD_RELOC_UNUSED
;
2478 assert (ep
->X_op
== O_symbol
);
2479 /* _gp_disp is a special case, used from s_cpload. */
2480 assert (mips_pic
== NO_PIC
2481 || strcmp (S_GET_NAME (ep
->X_add_symbol
), "_gp_disp") == 0);
2482 r
= BFD_RELOC_HI16_S
;
2486 * If the macro is about to expand into a second instruction,
2487 * print a warning if needed. We need to pass ip as a parameter
2488 * to generate a better warning message here...
2490 if (mips_warn_about_macros
&& place
== NULL
&& *counter
== 1)
2491 as_warn ("Macro instruction expanded into multiple instructions");
2494 *counter
+= 1; /* bump instruction counter */
2496 insn
.insn_mo
= (struct mips_opcode
*) hash_find (op_hash
, name
);
2497 assert (insn
.insn_mo
);
2498 assert (strcmp (name
, insn
.insn_mo
->name
) == 0);
2499 assert (strcmp (fmt
, insn
.insn_mo
->args
) == 0);
2501 insn
.insn_opcode
= insn
.insn_mo
->match
| (regnum
<< OP_SH_RT
);
2502 if (r
== BFD_RELOC_UNUSED
)
2504 insn
.insn_opcode
|= high_expr
.X_add_number
;
2505 append_insn (place
, &insn
, NULL
, r
, false);
2508 append_insn (place
, &insn
, &high_expr
, r
, false);
2512 * Generates code to set the $at register to true (one)
2513 * if reg is less than the immediate expression.
2516 set_at (counter
, reg
, unsignedp
)
2521 if (imm_expr
.X_add_number
>= -0x8000 && imm_expr
.X_add_number
< 0x8000)
2522 macro_build ((char *) NULL
, counter
, &imm_expr
,
2523 unsignedp
? "sltiu" : "slti",
2524 "t,r,j", AT
, reg
, (int) BFD_RELOC_LO16
);
2527 load_register (counter
, AT
, &imm_expr
, 0);
2528 macro_build ((char *) NULL
, counter
, NULL
,
2529 unsignedp
? "sltu" : "slt",
2530 "d,v,t", AT
, reg
, AT
);
2534 /* Warn if an expression is not a constant. */
2537 check_absolute_expr (ip
, ex
)
2538 struct mips_cl_insn
*ip
;
2541 if (ex
->X_op
!= O_constant
)
2542 as_warn ("Instruction %s requires absolute expression", ip
->insn_mo
->name
);
2545 /* Count the leading zeroes by performing a binary chop. This is a
2546 bulky bit of source, but performance is a LOT better for the
2547 majority of values than a simple loop to count the bits:
2548 for (lcnt = 0; (lcnt < 32); lcnt++)
2549 if ((v) & (1 << (31 - lcnt)))
2551 However it is not code size friendly, and the gain will drop a bit
2552 on certain cached systems.
2554 #define COUNT_TOP_ZEROES(v) \
2555 (((v) & ~0xffff) == 0 \
2556 ? ((v) & ~0xff) == 0 \
2557 ? ((v) & ~0xf) == 0 \
2558 ? ((v) & ~0x3) == 0 \
2559 ? ((v) & ~0x1) == 0 \
2564 : ((v) & ~0x7) == 0 \
2567 : ((v) & ~0x3f) == 0 \
2568 ? ((v) & ~0x1f) == 0 \
2571 : ((v) & ~0x7f) == 0 \
2574 : ((v) & ~0xfff) == 0 \
2575 ? ((v) & ~0x3ff) == 0 \
2576 ? ((v) & ~0x1ff) == 0 \
2579 : ((v) & ~0x7ff) == 0 \
2582 : ((v) & ~0x3fff) == 0 \
2583 ? ((v) & ~0x1fff) == 0 \
2586 : ((v) & ~0x7fff) == 0 \
2589 : ((v) & ~0xffffff) == 0 \
2590 ? ((v) & ~0xfffff) == 0 \
2591 ? ((v) & ~0x3ffff) == 0 \
2592 ? ((v) & ~0x1ffff) == 0 \
2595 : ((v) & ~0x7ffff) == 0 \
2598 : ((v) & ~0x3fffff) == 0 \
2599 ? ((v) & ~0x1fffff) == 0 \
2602 : ((v) & ~0x7fffff) == 0 \
2605 : ((v) & ~0xfffffff) == 0 \
2606 ? ((v) & ~0x3ffffff) == 0 \
2607 ? ((v) & ~0x1ffffff) == 0 \
2610 : ((v) & ~0x7ffffff) == 0 \
2613 : ((v) & ~0x3fffffff) == 0 \
2614 ? ((v) & ~0x1fffffff) == 0 \
2617 : ((v) & ~0x7fffffff) == 0 \
2622 * This routine generates the least number of instructions neccessary to load
2623 * an absolute expression value into a register.
2626 load_register (counter
, reg
, ep
, dbl
)
2633 expressionS hi32
, lo32
;
2635 if (ep
->X_op
!= O_big
)
2637 assert (ep
->X_op
== O_constant
);
2638 if (ep
->X_add_number
< 0x8000
2639 && (ep
->X_add_number
>= 0
2640 || (ep
->X_add_number
>= -0x8000
2643 || sizeof (ep
->X_add_number
) > 4))))
2645 /* We can handle 16 bit signed values with an addiu to
2646 $zero. No need to ever use daddiu here, since $zero and
2647 the result are always correct in 32 bit mode. */
2648 macro_build ((char *) NULL
, counter
, ep
, "addiu", "t,r,j", reg
, 0,
2649 (int) BFD_RELOC_LO16
);
2652 else if (ep
->X_add_number
>= 0 && ep
->X_add_number
< 0x10000)
2654 /* We can handle 16 bit unsigned values with an ori to
2656 macro_build ((char *) NULL
, counter
, ep
, "ori", "t,r,i", reg
, 0,
2657 (int) BFD_RELOC_LO16
);
2660 else if ((((ep
->X_add_number
&~ (offsetT
) 0x7fffffff) == 0
2661 || ((ep
->X_add_number
&~ (offsetT
) 0x7fffffff)
2662 == ~ (offsetT
) 0x7fffffff))
2665 || sizeof (ep
->X_add_number
) > 4
2666 || (ep
->X_add_number
& 0x80000000) == 0))
2667 || ((mips_isa
< 3 || !dbl
)
2668 && (ep
->X_add_number
&~ (offsetT
) 0xffffffff) == 0))
2670 /* 32 bit values require an lui. */
2671 macro_build ((char *) NULL
, counter
, ep
, "lui", "t,u", reg
,
2672 (int) BFD_RELOC_HI16
);
2673 if ((ep
->X_add_number
& 0xffff) != 0)
2674 macro_build ((char *) NULL
, counter
, ep
, "ori", "t,r,i", reg
, reg
,
2675 (int) BFD_RELOC_LO16
);
2680 /* The value is larger than 32 bits. */
2684 as_bad ("Number larger than 32 bits");
2685 macro_build ((char *) NULL
, counter
, ep
, "addiu", "t,r,j", reg
, 0,
2686 (int) BFD_RELOC_LO16
);
2690 if (ep
->X_op
!= O_big
)
2693 hi32
.X_add_number
= (valueT
) hi32
.X_add_number
>> 16;
2694 hi32
.X_add_number
= (valueT
) hi32
.X_add_number
>> 16;
2695 hi32
.X_add_number
&= 0xffffffff;
2697 lo32
.X_add_number
&= 0xffffffff;
2701 assert (ep
->X_add_number
> 2);
2702 if (ep
->X_add_number
== 3)
2703 generic_bignum
[3] = 0;
2704 else if (ep
->X_add_number
> 4)
2705 as_bad ("Number larger than 64 bits");
2706 lo32
.X_op
= O_constant
;
2707 lo32
.X_add_number
= generic_bignum
[0] + (generic_bignum
[1] << 16);
2708 hi32
.X_op
= O_constant
;
2709 hi32
.X_add_number
= generic_bignum
[2] + (generic_bignum
[3] << 16);
2712 if (hi32
.X_add_number
== 0)
2717 unsigned long hi
, lo
;
2719 if (hi32
.X_add_number
== 0xffffffff)
2721 if ((lo32
.X_add_number
& 0xffff8000) == 0xffff8000)
2723 macro_build ((char *) NULL
, counter
, &lo32
, "addiu", "t,r,j",
2724 reg
, 0, (int) BFD_RELOC_LO16
);
2727 if (lo32
.X_add_number
& 0x80000000)
2729 macro_build ((char *) NULL
, counter
, &lo32
, "lui", "t,u", reg
,
2730 (int) BFD_RELOC_HI16
);
2731 if (lo32
.X_add_number
& 0xffff)
2732 macro_build ((char *) NULL
, counter
, &lo32
, "ori", "t,r,i",
2733 reg
, reg
, (int) BFD_RELOC_LO16
);
2738 /* Check for 16bit shifted constant. We know that hi32 is
2739 non-zero, so start the mask on the first bit of the hi32
2744 unsigned long himask
, lomask
;
2748 himask
= 0xffff >> (32 - shift
);
2749 lomask
= (0xffff << shift
) & 0xffffffff;
2753 himask
= 0xffff << (shift
- 32);
2756 if ((hi32
.X_add_number
& ~ (offsetT
) himask
) == 0
2757 && (lo32
.X_add_number
& ~ (offsetT
) lomask
) == 0)
2761 tmp
.X_op
= O_constant
;
2763 tmp
.X_add_number
= ((hi32
.X_add_number
<< (32 - shift
))
2764 | (lo32
.X_add_number
>> shift
));
2766 tmp
.X_add_number
= hi32
.X_add_number
>> (shift
- 32);
2767 macro_build ((char *) NULL
, counter
, &tmp
, "ori", "t,r,i", reg
, 0,
2768 (int) BFD_RELOC_LO16
);
2769 macro_build ((char *) NULL
, counter
, NULL
,
2770 (shift
>= 32) ? "dsll32" : "dsll",
2772 (shift
>= 32) ? shift
- 32 : shift
);
2776 } while (shift
<= (64 - 16));
2778 /* Find the bit number of the lowest one bit, and store the
2779 shifted value in hi/lo. */
2780 hi
= (unsigned long) (hi32
.X_add_number
& 0xffffffff);
2781 lo
= (unsigned long) (lo32
.X_add_number
& 0xffffffff);
2785 while ((lo
& 1) == 0)
2790 lo
|= (hi
& (((unsigned long) 1 << bit
) - 1)) << (32 - bit
);
2796 while ((hi
& 1) == 0)
2805 /* Optimize if the shifted value is a (power of 2) - 1. */
2806 if ((hi
== 0 && ((lo
+ 1) & lo
) == 0)
2807 || (lo
== 0xffffffff && ((hi
+ 1) & hi
) == 0))
2809 shift
= COUNT_TOP_ZEROES ((unsigned int) hi32
.X_add_number
);
2814 /* This instruction will set the register to be all
2816 tmp
.X_op
= O_constant
;
2817 tmp
.X_add_number
= (offsetT
) -1;
2818 macro_build ((char *) NULL
, counter
, &tmp
, "addiu", "t,r,j",
2819 reg
, 0, (int) BFD_RELOC_LO16
);
2823 macro_build ((char *) NULL
, counter
, NULL
,
2824 (bit
>= 32) ? "dsll32" : "dsll",
2826 (bit
>= 32) ? bit
- 32 : bit
);
2828 macro_build ((char *) NULL
, counter
, NULL
,
2829 (shift
>= 32) ? "dsrl32" : "dsrl",
2831 (shift
>= 32) ? shift
- 32 : shift
);
2836 /* Sign extend hi32 before calling load_register, because we can
2837 generally get better code when we load a sign extended value. */
2838 if ((hi32
.X_add_number
& 0x80000000) != 0)
2839 hi32
.X_add_number
|= ~ (offsetT
) 0xffffffff;
2840 load_register (counter
, reg
, &hi32
, 0);
2843 if ((lo32
.X_add_number
& 0xffff0000) == 0)
2847 macro_build ((char *) NULL
, counter
, NULL
, "dsll32", "d,w,<", reg
,
2856 if ((freg
== 0) && (lo32
.X_add_number
== 0xffffffff))
2858 macro_build ((char *) NULL
, counter
, &lo32
, "lui", "t,u", reg
,
2859 (int) BFD_RELOC_HI16
);
2860 macro_build ((char *) NULL
, counter
, NULL
, "dsrl32", "d,w,<", reg
,
2867 macro_build ((char *) NULL
, counter
, NULL
, "dsll", "d,w,<", reg
,
2872 mid16
.X_add_number
>>= 16;
2873 macro_build ((char *) NULL
, counter
, &mid16
, "ori", "t,r,i", reg
,
2874 freg
, (int) BFD_RELOC_LO16
);
2875 macro_build ((char *) NULL
, counter
, NULL
, "dsll", "d,w,<", reg
,
2879 if ((lo32
.X_add_number
& 0xffff) != 0)
2880 macro_build ((char *) NULL
, counter
, &lo32
, "ori", "t,r,i", reg
, freg
,
2881 (int) BFD_RELOC_LO16
);
2884 /* Load an address into a register. */
2887 load_address (counter
, reg
, ep
)
2894 if (ep
->X_op
!= O_constant
2895 && ep
->X_op
!= O_symbol
)
2897 as_bad ("expression too complex");
2898 ep
->X_op
= O_constant
;
2901 if (ep
->X_op
== O_constant
)
2903 load_register (counter
, reg
, ep
, 0);
2907 if (mips_pic
== NO_PIC
)
2909 /* If this is a reference to a GP relative symbol, we want
2910 addiu $reg,$gp,<sym> (BFD_RELOC_MIPS_GPREL)
2912 lui $reg,<sym> (BFD_RELOC_HI16_S)
2913 addiu $reg,$reg,<sym> (BFD_RELOC_LO16)
2914 If we have an addend, we always use the latter form. */
2915 if ((valueT
) ep
->X_add_number
>= MAX_GPREL_OFFSET
2916 || nopic_need_relax (ep
->X_add_symbol
))
2921 macro_build ((char *) NULL
, counter
, ep
,
2922 mips_isa
< 3 ? "addiu" : "daddiu",
2923 "t,r,j", reg
, GP
, (int) BFD_RELOC_MIPS_GPREL
);
2924 p
= frag_var (rs_machine_dependent
, 8, 0,
2925 RELAX_ENCODE (4, 8, 0, 4, 0, mips_warn_about_macros
),
2926 ep
->X_add_symbol
, (long) 0, (char *) NULL
);
2928 macro_build_lui (p
, counter
, ep
, reg
);
2931 macro_build (p
, counter
, ep
,
2932 mips_isa
< 3 ? "addiu" : "daddiu",
2933 "t,r,j", reg
, reg
, (int) BFD_RELOC_LO16
);
2935 else if (mips_pic
== SVR4_PIC
&& ! mips_big_got
)
2939 /* If this is a reference to an external symbol, we want
2940 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
2942 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
2944 addiu $reg,$reg,<sym> (BFD_RELOC_LO16)
2945 If there is a constant, it must be added in after. */
2946 ex
.X_add_number
= ep
->X_add_number
;
2947 ep
->X_add_number
= 0;
2949 macro_build ((char *) NULL
, counter
, ep
,
2950 mips_isa
< 3 ? "lw" : "ld",
2951 "t,o(b)", reg
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
2952 macro_build ((char *) NULL
, counter
, (expressionS
*) NULL
, "nop", "");
2953 p
= frag_var (rs_machine_dependent
, 4, 0,
2954 RELAX_ENCODE (0, 4, -8, 0, 0, mips_warn_about_macros
),
2955 ep
->X_add_symbol
, (long) 0, (char *) NULL
);
2956 macro_build (p
, counter
, ep
,
2957 mips_isa
< 3 ? "addiu" : "daddiu",
2958 "t,r,j", reg
, reg
, (int) BFD_RELOC_LO16
);
2959 if (ex
.X_add_number
!= 0)
2961 if (ex
.X_add_number
< -0x8000 || ex
.X_add_number
>= 0x8000)
2962 as_bad ("PIC code offset overflow (max 16 signed bits)");
2963 ex
.X_op
= O_constant
;
2964 macro_build ((char *) NULL
, counter
, &ex
,
2965 mips_isa
< 3 ? "addiu" : "daddiu",
2966 "t,r,j", reg
, reg
, (int) BFD_RELOC_LO16
);
2969 else if (mips_pic
== SVR4_PIC
)
2974 /* This is the large GOT case. If this is a reference to an
2975 external symbol, we want
2976 lui $reg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
2978 lw $reg,<sym>($reg) (BFD_RELOC_MIPS_GOT_LO16)
2979 Otherwise, for a reference to a local symbol, we want
2980 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
2982 addiu $reg,$reg,<sym> (BFD_RELOC_LO16)
2983 If there is a constant, it must be added in after. */
2984 ex
.X_add_number
= ep
->X_add_number
;
2985 ep
->X_add_number
= 0;
2986 if (reg_needs_delay (GP
))
2991 macro_build ((char *) NULL
, counter
, ep
, "lui", "t,u", reg
,
2992 (int) BFD_RELOC_MIPS_GOT_HI16
);
2993 macro_build ((char *) NULL
, counter
, (expressionS
*) NULL
,
2994 mips_isa
< 3 ? "addu" : "daddu",
2995 "d,v,t", reg
, reg
, GP
);
2996 macro_build ((char *) NULL
, counter
, ep
,
2997 mips_isa
< 3 ? "lw" : "ld",
2998 "t,o(b)", reg
, (int) BFD_RELOC_MIPS_GOT_LO16
, reg
);
2999 p
= frag_var (rs_machine_dependent
, 12 + off
, 0,
3000 RELAX_ENCODE (12, 12 + off
, off
, 8 + off
, 0,
3001 mips_warn_about_macros
),
3002 ep
->X_add_symbol
, (long) 0, (char *) NULL
);
3005 /* We need a nop before loading from $gp. This special
3006 check is required because the lui which starts the main
3007 instruction stream does not refer to $gp, and so will not
3008 insert the nop which may be required. */
3009 macro_build (p
, counter
, (expressionS
*) NULL
, "nop", "");
3012 macro_build (p
, counter
, ep
,
3013 mips_isa
< 3 ? "lw" : "ld",
3014 "t,o(b)", reg
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
3016 macro_build (p
, counter
, (expressionS
*) NULL
, "nop", "");
3018 macro_build (p
, counter
, ep
,
3019 mips_isa
< 3 ? "addiu" : "daddiu",
3020 "t,r,j", reg
, reg
, (int) BFD_RELOC_LO16
);
3021 if (ex
.X_add_number
!= 0)
3023 if (ex
.X_add_number
< -0x8000 || ex
.X_add_number
>= 0x8000)
3024 as_bad ("PIC code offset overflow (max 16 signed bits)");
3025 ex
.X_op
= O_constant
;
3026 macro_build ((char *) NULL
, counter
, &ex
,
3027 mips_isa
< 3 ? "addiu" : "daddiu",
3028 "t,r,j", reg
, reg
, (int) BFD_RELOC_LO16
);
3031 else if (mips_pic
== EMBEDDED_PIC
)
3034 addiu $reg,$gp,<sym> (BFD_RELOC_MIPS_GPREL)
3036 macro_build ((char *) NULL
, counter
, ep
,
3037 mips_isa
< 3 ? "addiu" : "daddiu",
3038 "t,r,j", reg
, GP
, (int) BFD_RELOC_MIPS_GPREL
);
3046 * This routine implements the seemingly endless macro or synthesized
3047 * instructions and addressing modes in the mips assembly language. Many
3048 * of these macros are simple and are similar to each other. These could
3049 * probably be handled by some kind of table or grammer aproach instead of
3050 * this verbose method. Others are not simple macros but are more like
3051 * optimizing code generation.
3052 * One interesting optimization is when several store macros appear
3053 * consecutivly that would load AT with the upper half of the same address.
3054 * The ensuing load upper instructions are ommited. This implies some kind
3055 * of global optimization. We currently only optimize within a single macro.
3056 * For many of the load and store macros if the address is specified as a
3057 * constant expression in the first 64k of memory (ie ld $2,0x4000c) we
3058 * first load register 'at' with zero and use it as the base register. The
3059 * mips assembler simply uses register $zero. Just one tiny optimization
3064 struct mips_cl_insn
*ip
;
3066 register int treg
, sreg
, dreg
, breg
;
3081 bfd_reloc_code_real_type r
;
3083 int hold_mips_optimize
;
3087 treg
= (ip
->insn_opcode
>> 16) & 0x1f;
3088 dreg
= (ip
->insn_opcode
>> 11) & 0x1f;
3089 sreg
= breg
= (ip
->insn_opcode
>> 21) & 0x1f;
3090 mask
= ip
->insn_mo
->mask
;
3092 expr1
.X_op
= O_constant
;
3093 expr1
.X_op_symbol
= NULL
;
3094 expr1
.X_add_symbol
= NULL
;
3095 expr1
.X_add_number
= 1;
3107 mips_emit_delays (true);
3109 mips_any_noreorder
= 1;
3111 expr1
.X_add_number
= 8;
3112 macro_build ((char *) NULL
, &icnt
, &expr1
, "bgez", "s,p", sreg
);
3114 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "", 0);
3116 macro_build ((char *) NULL
, &icnt
, NULL
, "move", "d,s", dreg
, sreg
, 0);
3117 macro_build ((char *) NULL
, &icnt
, NULL
,
3118 dbl
? "dsub" : "sub",
3119 "d,v,t", dreg
, 0, sreg
);
3142 if (imm_expr
.X_add_number
>= -0x8000 && imm_expr
.X_add_number
< 0x8000)
3144 macro_build ((char *) NULL
, &icnt
, &imm_expr
, s
, "t,r,j", treg
, sreg
,
3145 (int) BFD_RELOC_LO16
);
3148 load_register (&icnt
, AT
, &imm_expr
, dbl
);
3149 macro_build ((char *) NULL
, &icnt
, NULL
, s2
, "d,v,t", treg
, sreg
, AT
);
3168 if (imm_expr
.X_add_number
>= 0 && imm_expr
.X_add_number
< 0x10000)
3170 if (mask
!= M_NOR_I
)
3171 macro_build ((char *) NULL
, &icnt
, &imm_expr
, s
, "t,r,i", treg
,
3172 sreg
, (int) BFD_RELOC_LO16
);
3175 macro_build ((char *) NULL
, &icnt
, &imm_expr
, "ori", "t,r,i",
3176 treg
, sreg
, (int) BFD_RELOC_LO16
);
3177 macro_build ((char *) NULL
, &icnt
, NULL
, "nor", "d,v,t",
3183 load_register (&icnt
, AT
, &imm_expr
, 0);
3184 macro_build ((char *) NULL
, &icnt
, NULL
, s2
, "d,v,t", treg
, sreg
, AT
);
3201 if (imm_expr
.X_add_number
== 0)
3203 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, "s,t,p", sreg
,
3207 load_register (&icnt
, AT
, &imm_expr
, 0);
3208 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, "s,t,p", sreg
, AT
);
3216 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3217 likely
? "bgezl" : "bgez",
3223 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3224 likely
? "blezl" : "blez",
3228 macro_build ((char *) NULL
, &icnt
, NULL
, "slt", "d,v,t", AT
, sreg
, treg
);
3229 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3230 likely
? "beql" : "beq",
3237 /* check for > max integer */
3238 maxnum
= 0x7fffffff;
3246 if (imm_expr
.X_add_number
>= maxnum
3247 && (mips_isa
< 3 || sizeof (maxnum
) > 4))
3250 /* result is always false */
3253 as_warn ("Branch %s is always false (nop)", ip
->insn_mo
->name
);
3254 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "", 0);
3258 as_warn ("Branch likely %s is always false", ip
->insn_mo
->name
);
3259 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "bnel",
3264 imm_expr
.X_add_number
++;
3268 if (mask
== M_BGEL_I
)
3270 if (imm_expr
.X_add_number
== 0)
3272 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3273 likely
? "bgezl" : "bgez",
3277 if (imm_expr
.X_add_number
== 1)
3279 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3280 likely
? "bgtzl" : "bgtz",
3284 maxnum
= 0x7fffffff;
3292 maxnum
= - maxnum
- 1;
3293 if (imm_expr
.X_add_number
<= maxnum
3294 && (mips_isa
< 3 || sizeof (maxnum
) > 4))
3297 /* result is always true */
3298 as_warn ("Branch %s is always true", ip
->insn_mo
->name
);
3299 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "b", "p");
3302 set_at (&icnt
, sreg
, 0);
3303 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3304 likely
? "beql" : "beq",
3315 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3316 likely
? "beql" : "beq",
3320 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", AT
, sreg
,
3322 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3323 likely
? "beql" : "beq",
3330 if (sreg
== 0 || imm_expr
.X_add_number
== -1)
3332 imm_expr
.X_add_number
++;
3336 if (mask
== M_BGEUL_I
)
3338 if (imm_expr
.X_add_number
== 0)
3340 if (imm_expr
.X_add_number
== 1)
3342 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3343 likely
? "bnel" : "bne",
3347 set_at (&icnt
, sreg
, 1);
3348 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3349 likely
? "beql" : "beq",
3358 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3359 likely
? "bgtzl" : "bgtz",
3365 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3366 likely
? "bltzl" : "bltz",
3370 macro_build ((char *) NULL
, &icnt
, NULL
, "slt", "d,v,t", AT
, treg
, sreg
);
3371 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3372 likely
? "bnel" : "bne",
3381 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3382 likely
? "bnel" : "bne",
3388 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", AT
, treg
,
3390 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3391 likely
? "bnel" : "bne",
3400 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3401 likely
? "blezl" : "blez",
3407 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3408 likely
? "bgezl" : "bgez",
3412 macro_build ((char *) NULL
, &icnt
, NULL
, "slt", "d,v,t", AT
, treg
, sreg
);
3413 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3414 likely
? "beql" : "beq",
3421 maxnum
= 0x7fffffff;
3429 if (imm_expr
.X_add_number
>= maxnum
3430 && (mips_isa
< 3 || sizeof (maxnum
) > 4))
3432 imm_expr
.X_add_number
++;
3436 if (mask
== M_BLTL_I
)
3438 if (imm_expr
.X_add_number
== 0)
3440 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3441 likely
? "bltzl" : "bltz",
3445 if (imm_expr
.X_add_number
== 1)
3447 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3448 likely
? "blezl" : "blez",
3452 set_at (&icnt
, sreg
, 0);
3453 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3454 likely
? "bnel" : "bne",
3463 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3464 likely
? "beql" : "beq",
3470 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", AT
, treg
,
3472 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3473 likely
? "beql" : "beq",
3480 if (sreg
== 0 || imm_expr
.X_add_number
== -1)
3482 imm_expr
.X_add_number
++;
3486 if (mask
== M_BLTUL_I
)
3488 if (imm_expr
.X_add_number
== 0)
3490 if (imm_expr
.X_add_number
== 1)
3492 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3493 likely
? "beql" : "beq",
3497 set_at (&icnt
, sreg
, 1);
3498 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3499 likely
? "bnel" : "bne",
3508 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3509 likely
? "bltzl" : "bltz",
3515 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3516 likely
? "bgtzl" : "bgtz",
3520 macro_build ((char *) NULL
, &icnt
, NULL
, "slt", "d,v,t", AT
, sreg
, treg
);
3521 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3522 likely
? "bnel" : "bne",
3533 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3534 likely
? "bnel" : "bne",
3538 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", AT
, sreg
,
3540 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3541 likely
? "bnel" : "bne",
3557 as_warn ("Divide by zero.");
3559 macro_build ((char *) NULL
, &icnt
, NULL
, "teq", "s,t", 0, 0);
3561 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "c", 7);
3565 mips_emit_delays (true);
3567 mips_any_noreorder
= 1;
3568 macro_build ((char *) NULL
, &icnt
, NULL
,
3569 dbl
? "ddiv" : "div",
3570 "z,s,t", sreg
, treg
);
3572 macro_build ((char *) NULL
, &icnt
, NULL
, "teq", "s,t", treg
, 0);
3575 expr1
.X_add_number
= 8;
3576 macro_build ((char *) NULL
, &icnt
, &expr1
, "bne", "s,t,p", treg
, 0);
3577 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "", 0);
3578 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "c", 7);
3580 expr1
.X_add_number
= -1;
3581 macro_build ((char *) NULL
, &icnt
, &expr1
,
3582 dbl
? "daddiu" : "addiu",
3583 "t,r,j", AT
, 0, (int) BFD_RELOC_LO16
);
3584 expr1
.X_add_number
= mips_trap
? (dbl
? 12 : 8) : (dbl
? 20 : 16);
3585 macro_build ((char *) NULL
, &icnt
, &expr1
, "bne", "s,t,p", treg
, AT
);
3588 expr1
.X_add_number
= 1;
3589 macro_build ((char *) NULL
, &icnt
, &expr1
, "daddiu", "t,r,j", AT
, 0,
3590 (int) BFD_RELOC_LO16
);
3591 macro_build ((char *) NULL
, &icnt
, NULL
, "dsll32", "d,w,<", AT
, AT
,
3596 expr1
.X_add_number
= 0x80000000;
3597 macro_build ((char *) NULL
, &icnt
, &expr1
, "lui", "t,u", AT
,
3598 (int) BFD_RELOC_HI16
);
3601 macro_build ((char *) NULL
, &icnt
, NULL
, "teq", "s,t", sreg
, AT
);
3604 expr1
.X_add_number
= 8;
3605 macro_build ((char *) NULL
, &icnt
, &expr1
, "bne", "s,t,p", sreg
, AT
);
3606 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "", 0);
3607 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "c", 6);
3610 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "d", dreg
);
3649 if (imm_expr
.X_add_number
== 0)
3651 as_warn ("Divide by zero.");
3653 macro_build ((char *) NULL
, &icnt
, NULL
, "teq", "s,t", 0, 0);
3655 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "c", 7);
3658 if (imm_expr
.X_add_number
== 1)
3660 if (strcmp (s2
, "mflo") == 0)
3661 macro_build ((char *) NULL
, &icnt
, NULL
, "move", "d,s", dreg
,
3664 macro_build ((char *) NULL
, &icnt
, NULL
, "move", "d,s", dreg
, 0);
3667 if (imm_expr
.X_add_number
== -1
3668 && s
[strlen (s
) - 1] != 'u')
3670 if (strcmp (s2
, "mflo") == 0)
3673 macro_build ((char *) NULL
, &icnt
, NULL
, "dneg", "d,w", dreg
,
3676 macro_build ((char *) NULL
, &icnt
, NULL
, "neg", "d,w", dreg
,
3680 macro_build ((char *) NULL
, &icnt
, NULL
, "move", "d,s", dreg
, 0);
3684 load_register (&icnt
, AT
, &imm_expr
, dbl
);
3685 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "z,s,t", sreg
, AT
);
3686 macro_build ((char *) NULL
, &icnt
, NULL
, s2
, "d", dreg
);
3705 mips_emit_delays (true);
3707 mips_any_noreorder
= 1;
3708 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "z,s,t", sreg
, treg
);
3710 macro_build ((char *) NULL
, &icnt
, NULL
, "teq", "s,t", treg
, 0);
3713 expr1
.X_add_number
= 8;
3714 macro_build ((char *) NULL
, &icnt
, &expr1
, "bne", "s,t,p", treg
, 0);
3715 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "", 0);
3716 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "c", 7);
3719 macro_build ((char *) NULL
, &icnt
, NULL
, s2
, "d", dreg
);
3725 /* Load the address of a symbol into a register. If breg is not
3726 zero, we then add a base register to it. */
3728 /* When generating embedded PIC code, we permit expressions of
3731 where bar is an address in the .text section. These are used
3732 when getting the addresses of functions. We don't permit
3733 X_add_number to be non-zero, because if the symbol is
3734 external the relaxing code needs to know that any addend is
3735 purely the offset to X_op_symbol. */
3736 if (mips_pic
== EMBEDDED_PIC
3737 && offset_expr
.X_op
== O_subtract
3738 && now_seg
== text_section
3739 && (offset_expr
.X_op_symbol
->sy_value
.X_op
== O_constant
3740 ? S_GET_SEGMENT (offset_expr
.X_op_symbol
) == text_section
3741 : (offset_expr
.X_op_symbol
->sy_value
.X_op
== O_symbol
3742 && (S_GET_SEGMENT (offset_expr
.X_op_symbol
3743 ->sy_value
.X_add_symbol
)
3746 && offset_expr
.X_add_number
== 0)
3748 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lui", "t,u",
3749 treg
, (int) BFD_RELOC_PCREL_HI16_S
);
3750 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3751 mips_isa
< 3 ? "addiu" : "daddiu",
3752 "t,r,j", treg
, treg
, (int) BFD_RELOC_PCREL_LO16
);
3756 if (offset_expr
.X_op
!= O_symbol
3757 && offset_expr
.X_op
!= O_constant
)
3759 as_bad ("expression too complex");
3760 offset_expr
.X_op
= O_constant
;
3774 if (offset_expr
.X_op
== O_constant
)
3775 load_register (&icnt
, tempreg
, &offset_expr
, dbl
);
3776 else if (mips_pic
== NO_PIC
)
3778 /* If this is a reference to an GP relative symbol, we want
3779 addiu $tempreg,$gp,<sym> (BFD_RELOC_MIPS_GPREL)
3781 lui $tempreg,<sym> (BFD_RELOC_HI16_S)
3782 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
3783 If we have a constant, we need two instructions anyhow,
3784 so we may as well always use the latter form. */
3785 if ((valueT
) offset_expr
.X_add_number
>= MAX_GPREL_OFFSET
3786 || nopic_need_relax (offset_expr
.X_add_symbol
))
3791 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3792 mips_isa
< 3 ? "addiu" : "daddiu",
3793 "t,r,j", tempreg
, GP
, (int) BFD_RELOC_MIPS_GPREL
);
3794 p
= frag_var (rs_machine_dependent
, 8, 0,
3795 RELAX_ENCODE (4, 8, 0, 4, 0,
3796 mips_warn_about_macros
),
3797 offset_expr
.X_add_symbol
, (long) 0,
3800 macro_build_lui (p
, &icnt
, &offset_expr
, tempreg
);
3803 macro_build (p
, &icnt
, &offset_expr
,
3804 mips_isa
< 3 ? "addiu" : "daddiu",
3805 "t,r,j", tempreg
, tempreg
, (int) BFD_RELOC_LO16
);
3807 else if (mips_pic
== SVR4_PIC
&& ! mips_big_got
)
3809 /* If this is a reference to an external symbol, and there
3810 is no constant, we want
3811 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
3812 For a local symbol, we want
3813 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
3815 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
3817 If we have a small constant, and this is a reference to
3818 an external symbol, we want
3819 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
3821 addiu $tempreg,$tempreg,<constant>
3822 For a local symbol, we want the same instruction
3823 sequence, but we output a BFD_RELOC_LO16 reloc on the
3826 If we have a large constant, and this is a reference to
3827 an external symbol, we want
3828 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
3829 lui $at,<hiconstant>
3830 addiu $at,$at,<loconstant>
3831 addu $tempreg,$tempreg,$at
3832 For a local symbol, we want the same instruction
3833 sequence, but we output a BFD_RELOC_LO16 reloc on the
3834 addiu instruction. */
3835 expr1
.X_add_number
= offset_expr
.X_add_number
;
3836 offset_expr
.X_add_number
= 0;
3838 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3840 "t,o(b)", tempreg
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
3841 if (expr1
.X_add_number
== 0)
3849 /* We're going to put in an addu instruction using
3850 tempreg, so we may as well insert the nop right
3852 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
3856 p
= frag_var (rs_machine_dependent
, 8 - off
, 0,
3857 RELAX_ENCODE (0, 8 - off
, -4 - off
, 4 - off
, 0,
3859 ? mips_warn_about_macros
3861 offset_expr
.X_add_symbol
, (long) 0,
3865 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
3868 macro_build (p
, &icnt
, &expr1
,
3869 mips_isa
< 3 ? "addiu" : "daddiu",
3870 "t,r,j", tempreg
, tempreg
, (int) BFD_RELOC_LO16
);
3871 /* FIXME: If breg == 0, and the next instruction uses
3872 $tempreg, then if this variant case is used an extra
3873 nop will be generated. */
3875 else if (expr1
.X_add_number
>= -0x8000
3876 && expr1
.X_add_number
< 0x8000)
3878 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
3880 macro_build ((char *) NULL
, &icnt
, &expr1
,
3881 mips_isa
< 3 ? "addiu" : "daddiu",
3882 "t,r,j", tempreg
, tempreg
, (int) BFD_RELOC_LO16
);
3883 (void) frag_var (rs_machine_dependent
, 0, 0,
3884 RELAX_ENCODE (0, 0, -12, -4, 0, 0),
3885 offset_expr
.X_add_symbol
, (long) 0,
3892 /* If we are going to add in a base register, and the
3893 target register and the base register are the same,
3894 then we are using AT as a temporary register. Since
3895 we want to load the constant into AT, we add our
3896 current AT (from the global offset table) and the
3897 register into the register now, and pretend we were
3898 not using a base register. */
3903 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
3905 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
3906 mips_isa
< 3 ? "addu" : "daddu",
3907 "d,v,t", treg
, AT
, breg
);
3913 /* Set mips_optimize around the lui instruction to avoid
3914 inserting an unnecessary nop after the lw. */
3915 hold_mips_optimize
= mips_optimize
;
3917 macro_build_lui ((char *) NULL
, &icnt
, &expr1
, AT
);
3918 mips_optimize
= hold_mips_optimize
;
3920 macro_build ((char *) NULL
, &icnt
, &expr1
,
3921 mips_isa
< 3 ? "addiu" : "daddiu",
3922 "t,r,j", AT
, AT
, (int) BFD_RELOC_LO16
);
3923 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
3924 mips_isa
< 3 ? "addu" : "daddu",
3925 "d,v,t", tempreg
, tempreg
, AT
);
3926 (void) frag_var (rs_machine_dependent
, 0, 0,
3927 RELAX_ENCODE (0, 0, -16 + off1
, -8, 0, 0),
3928 offset_expr
.X_add_symbol
, (long) 0,
3933 else if (mips_pic
== SVR4_PIC
)
3937 /* This is the large GOT case. If this is a reference to an
3938 external symbol, and there is no constant, we want
3939 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
3940 addu $tempreg,$tempreg,$gp
3941 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
3942 For a local symbol, we want
3943 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
3945 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
3947 If we have a small constant, and this is a reference to
3948 an external symbol, we want
3949 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
3950 addu $tempreg,$tempreg,$gp
3951 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
3953 addiu $tempreg,$tempreg,<constant>
3954 For a local symbol, we want
3955 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
3957 addiu $tempreg,$tempreg,<constant> (BFD_RELOC_LO16)
3959 If we have a large constant, and this is a reference to
3960 an external symbol, we want
3961 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
3962 addu $tempreg,$tempreg,$gp
3963 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
3964 lui $at,<hiconstant>
3965 addiu $at,$at,<loconstant>
3966 addu $tempreg,$tempreg,$at
3967 For a local symbol, we want
3968 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
3969 lui $at,<hiconstant>
3970 addiu $at,$at,<loconstant> (BFD_RELOC_LO16)
3971 addu $tempreg,$tempreg,$at
3973 expr1
.X_add_number
= offset_expr
.X_add_number
;
3974 offset_expr
.X_add_number
= 0;
3976 if (reg_needs_delay (GP
))
3980 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lui", "t,u",
3981 tempreg
, (int) BFD_RELOC_MIPS_GOT_HI16
);
3982 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
3983 mips_isa
< 3 ? "addu" : "daddu",
3984 "d,v,t", tempreg
, tempreg
, GP
);
3985 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
3987 "t,o(b)", tempreg
, (int) BFD_RELOC_MIPS_GOT_LO16
,
3989 if (expr1
.X_add_number
== 0)
3997 /* We're going to put in an addu instruction using
3998 tempreg, so we may as well insert the nop right
4000 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4005 p
= frag_var (rs_machine_dependent
, 12 + gpdel
, 0,
4006 RELAX_ENCODE (12 + off
, 12 + gpdel
, gpdel
,
4009 ? mips_warn_about_macros
4011 offset_expr
.X_add_symbol
, (long) 0,
4014 else if (expr1
.X_add_number
>= -0x8000
4015 && expr1
.X_add_number
< 0x8000)
4017 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4019 macro_build ((char *) NULL
, &icnt
, &expr1
,
4020 mips_isa
< 3 ? "addiu" : "daddiu",
4021 "t,r,j", tempreg
, tempreg
, (int) BFD_RELOC_LO16
);
4023 p
= frag_var (rs_machine_dependent
, 12 + gpdel
, 0,
4024 RELAX_ENCODE (20, 12 + gpdel
, gpdel
, 8 + gpdel
, 0,
4026 ? mips_warn_about_macros
4028 offset_expr
.X_add_symbol
, (long) 0,
4035 /* If we are going to add in a base register, and the
4036 target register and the base register are the same,
4037 then we are using AT as a temporary register. Since
4038 we want to load the constant into AT, we add our
4039 current AT (from the global offset table) and the
4040 register into the register now, and pretend we were
4041 not using a base register. */
4049 assert (tempreg
== AT
);
4050 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4052 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4053 mips_isa
< 3 ? "addu" : "daddu",
4054 "d,v,t", treg
, AT
, breg
);
4059 /* Set mips_optimize around the lui instruction to avoid
4060 inserting an unnecessary nop after the lw. */
4061 hold_mips_optimize
= mips_optimize
;
4063 macro_build_lui ((char *) NULL
, &icnt
, &expr1
, AT
);
4064 mips_optimize
= hold_mips_optimize
;
4066 macro_build ((char *) NULL
, &icnt
, &expr1
,
4067 mips_isa
< 3 ? "addiu" : "daddiu",
4068 "t,r,j", AT
, AT
, (int) BFD_RELOC_LO16
);
4069 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4070 mips_isa
< 3 ? "addu" : "daddu",
4071 "d,v,t", dreg
, dreg
, AT
);
4073 p
= frag_var (rs_machine_dependent
, 16 + gpdel
+ adj
, 0,
4074 RELAX_ENCODE (24 + adj
, 16 + gpdel
+ adj
, gpdel
,
4077 ? mips_warn_about_macros
4079 offset_expr
.X_add_symbol
, (long) 0,
4087 /* This is needed because this instruction uses $gp, but
4088 the first instruction on the main stream does not. */
4089 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
4092 macro_build (p
, &icnt
, &offset_expr
,
4094 "t,o(b)", tempreg
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
4096 if (expr1
.X_add_number
>= -0x8000
4097 && expr1
.X_add_number
< 0x8000)
4099 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
4101 macro_build (p
, &icnt
, &expr1
,
4102 mips_isa
< 3 ? "addiu" : "daddiu",
4103 "t,r,j", tempreg
, tempreg
, (int) BFD_RELOC_LO16
);
4104 /* FIXME: If add_number is 0, and there was no base
4105 register, the external symbol case ended with a load,
4106 so if the symbol turns out to not be external, and
4107 the next instruction uses tempreg, an unnecessary nop
4108 will be inserted. */
4114 /* We must add in the base register now, as in the
4115 external symbol case. */
4116 assert (tempreg
== AT
);
4117 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
4119 macro_build (p
, &icnt
, (expressionS
*) NULL
,
4120 mips_isa
< 3 ? "addu" : "daddu",
4121 "d,v,t", treg
, AT
, breg
);
4124 /* We set breg to 0 because we have arranged to add
4125 it in in both cases. */
4129 macro_build_lui (p
, &icnt
, &expr1
, AT
);
4131 macro_build (p
, &icnt
, &expr1
,
4132 mips_isa
< 3 ? "addiu" : "daddiu",
4133 "t,r,j", AT
, AT
, (int) BFD_RELOC_LO16
);
4135 macro_build (p
, &icnt
, (expressionS
*) NULL
,
4136 mips_isa
< 3 ? "addu" : "daddu",
4137 "d,v,t", tempreg
, tempreg
, AT
);
4141 else if (mips_pic
== EMBEDDED_PIC
)
4144 addiu $tempreg,$gp,<sym> (BFD_RELOC_MIPS_GPREL)
4146 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4147 mips_isa
< 3 ? "addiu" : "daddiu",
4148 "t,r,j", tempreg
, GP
, (int) BFD_RELOC_MIPS_GPREL
);
4154 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4155 mips_isa
< 3 ? "addu" : "daddu",
4156 "d,v,t", treg
, tempreg
, breg
);
4164 /* The j instruction may not be used in PIC code, since it
4165 requires an absolute address. We convert it to a b
4167 if (mips_pic
== NO_PIC
)
4168 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "j", "a");
4170 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "b", "p");
4173 /* The jal instructions must be handled as macros because when
4174 generating PIC code they expand to multi-instruction
4175 sequences. Normally they are simple instructions. */
4180 if (mips_pic
== NO_PIC
4181 || mips_pic
== EMBEDDED_PIC
)
4182 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
, "jalr",
4184 else if (mips_pic
== SVR4_PIC
)
4186 if (sreg
!= PIC_CALL_REG
)
4187 as_warn ("MIPS PIC call to register other than $25");
4189 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
, "jalr",
4191 if (mips_cprestore_offset
< 0)
4192 as_warn ("No .cprestore pseudo-op used in PIC code");
4195 expr1
.X_add_number
= mips_cprestore_offset
;
4196 macro_build ((char *) NULL
, &icnt
, &expr1
,
4197 mips_isa
< 3 ? "lw" : "ld",
4198 "t,o(b)", GP
, (int) BFD_RELOC_LO16
, mips_frame_reg
);
4207 if (mips_pic
== NO_PIC
)
4208 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "jal", "a");
4209 else if (mips_pic
== SVR4_PIC
)
4211 /* If this is a reference to an external symbol, and we are
4212 using a small GOT, we want
4213 lw $25,<sym>($gp) (BFD_RELOC_MIPS_CALL16)
4217 lw $gp,cprestore($sp)
4218 The cprestore value is set using the .cprestore
4219 pseudo-op. If we are using a big GOT, we want
4220 lui $25,<sym> (BFD_RELOC_MIPS_CALL_HI16)
4222 lw $25,<sym>($25) (BFD_RELOC_MIPS_CALL_LO16)
4226 lw $gp,cprestore($sp)
4227 If the symbol is not external, we want
4228 lw $25,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
4230 addiu $25,$25,<sym> (BFD_RELOC_LO16)
4233 lw $gp,cprestore($sp) */
4237 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4238 mips_isa
< 3 ? "lw" : "ld",
4239 "t,o(b)", PIC_CALL_REG
,
4240 (int) BFD_RELOC_MIPS_CALL16
, GP
);
4241 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4243 p
= frag_var (rs_machine_dependent
, 4, 0,
4244 RELAX_ENCODE (0, 4, -8, 0, 0, 0),
4245 offset_expr
.X_add_symbol
, (long) 0, (char *) NULL
);
4251 if (reg_needs_delay (GP
))
4255 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lui", "t,u",
4256 PIC_CALL_REG
, (int) BFD_RELOC_MIPS_CALL_HI16
);
4257 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4258 mips_isa
< 3 ? "addu" : "daddu",
4259 "d,v,t", PIC_CALL_REG
, PIC_CALL_REG
, GP
);
4260 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4261 mips_isa
< 3 ? "lw" : "ld",
4262 "t,o(b)", PIC_CALL_REG
,
4263 (int) BFD_RELOC_MIPS_CALL_LO16
, PIC_CALL_REG
);
4264 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4266 p
= frag_var (rs_machine_dependent
, 12 + gpdel
, 0,
4267 RELAX_ENCODE (16, 12 + gpdel
, gpdel
, 8 + gpdel
,
4269 offset_expr
.X_add_symbol
, (long) 0, (char *) NULL
);
4272 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
4275 macro_build (p
, &icnt
, &offset_expr
,
4276 mips_isa
< 3 ? "lw" : "ld",
4277 "t,o(b)", PIC_CALL_REG
,
4278 (int) BFD_RELOC_MIPS_GOT16
, GP
);
4280 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
4283 macro_build (p
, &icnt
, &offset_expr
,
4284 mips_isa
< 3 ? "addiu" : "daddiu",
4285 "t,r,j", PIC_CALL_REG
, PIC_CALL_REG
,
4286 (int) BFD_RELOC_LO16
);
4287 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4288 "jalr", "s", PIC_CALL_REG
);
4289 if (mips_cprestore_offset
< 0)
4290 as_warn ("No .cprestore pseudo-op used in PIC code");
4294 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4296 expr1
.X_add_number
= mips_cprestore_offset
;
4297 macro_build ((char *) NULL
, &icnt
, &expr1
,
4298 mips_isa
< 3 ? "lw" : "ld",
4299 "t,o(b)", GP
, (int) BFD_RELOC_LO16
,
4303 else if (mips_pic
== EMBEDDED_PIC
)
4305 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "bal", "p");
4306 /* The linker may expand the call to a longer sequence which
4307 uses $at, so we must break rather than return. */
4383 if (breg
== treg
|| coproc
|| lr
)
4452 if (mask
== M_LWC1_AB
4453 || mask
== M_SWC1_AB
4454 || mask
== M_LDC1_AB
4455 || mask
== M_SDC1_AB
4464 if (offset_expr
.X_op
!= O_constant
4465 && offset_expr
.X_op
!= O_symbol
)
4467 as_bad ("expression too complex");
4468 offset_expr
.X_op
= O_constant
;
4471 /* A constant expression in PIC code can be handled just as it
4472 is in non PIC code. */
4473 if (mips_pic
== NO_PIC
4474 || offset_expr
.X_op
== O_constant
)
4476 /* If this is a reference to a GP relative symbol, and there
4477 is no base register, we want
4478 <op> $treg,<sym>($gp) (BFD_RELOC_MIPS_GPREL)
4479 Otherwise, if there is no base register, we want
4480 lui $tempreg,<sym> (BFD_RELOC_HI16_S)
4481 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
4482 If we have a constant, we need two instructions anyhow,
4483 so we always use the latter form.
4485 If we have a base register, and this is a reference to a
4486 GP relative symbol, we want
4487 addu $tempreg,$breg,$gp
4488 <op> $treg,<sym>($tempreg) (BFD_RELOC_MIPS_GPREL)
4490 lui $tempreg,<sym> (BFD_RELOC_HI16_S)
4491 addu $tempreg,$tempreg,$breg
4492 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
4493 With a constant we always use the latter case. */
4496 if ((valueT
) offset_expr
.X_add_number
>= MAX_GPREL_OFFSET
4497 || nopic_need_relax (offset_expr
.X_add_symbol
))
4502 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
4503 treg
, (int) BFD_RELOC_MIPS_GPREL
, GP
);
4504 p
= frag_var (rs_machine_dependent
, 8, 0,
4505 RELAX_ENCODE (4, 8, 0, 4, 0,
4506 (mips_warn_about_macros
4507 || (used_at
&& mips_noat
))),
4508 offset_expr
.X_add_symbol
, (long) 0,
4512 macro_build_lui (p
, &icnt
, &offset_expr
, tempreg
);
4515 macro_build (p
, &icnt
, &offset_expr
, s
, fmt
, treg
,
4516 (int) BFD_RELOC_LO16
, tempreg
);
4520 if ((valueT
) offset_expr
.X_add_number
>= MAX_GPREL_OFFSET
4521 || nopic_need_relax (offset_expr
.X_add_symbol
))
4526 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4527 mips_isa
< 3 ? "addu" : "daddu",
4528 "d,v,t", tempreg
, breg
, GP
);
4529 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
4530 treg
, (int) BFD_RELOC_MIPS_GPREL
, tempreg
);
4531 p
= frag_var (rs_machine_dependent
, 12, 0,
4532 RELAX_ENCODE (8, 12, 0, 8, 0, 0),
4533 offset_expr
.X_add_symbol
, (long) 0,
4536 macro_build_lui (p
, &icnt
, &offset_expr
, tempreg
);
4539 macro_build (p
, &icnt
, (expressionS
*) NULL
,
4540 mips_isa
< 3 ? "addu" : "daddu",
4541 "d,v,t", tempreg
, tempreg
, breg
);
4544 macro_build (p
, &icnt
, &offset_expr
, s
, fmt
, treg
,
4545 (int) BFD_RELOC_LO16
, tempreg
);
4548 else if (mips_pic
== SVR4_PIC
&& ! mips_big_got
)
4550 /* If this is a reference to an external symbol, we want
4551 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
4553 <op> $treg,0($tempreg)
4555 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
4557 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
4558 <op> $treg,0($tempreg)
4559 If there is a base register, we add it to $tempreg before
4560 the <op>. If there is a constant, we stick it in the
4561 <op> instruction. We don't handle constants larger than
4562 16 bits, because we have no way to load the upper 16 bits
4563 (actually, we could handle them for the subset of cases
4564 in which we are not using $at). */
4565 assert (offset_expr
.X_op
== O_symbol
);
4566 expr1
.X_add_number
= offset_expr
.X_add_number
;
4567 offset_expr
.X_add_number
= 0;
4568 if (expr1
.X_add_number
< -0x8000
4569 || expr1
.X_add_number
>= 0x8000)
4570 as_bad ("PIC code offset overflow (max 16 signed bits)");
4572 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4573 mips_isa
< 3 ? "lw" : "ld",
4574 "t,o(b)", tempreg
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
4575 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
, "nop", "");
4576 p
= frag_var (rs_machine_dependent
, 4, 0,
4577 RELAX_ENCODE (0, 4, -8, 0, 0, 0),
4578 offset_expr
.X_add_symbol
, (long) 0,
4580 macro_build (p
, &icnt
, &offset_expr
,
4581 mips_isa
< 3 ? "addiu" : "daddiu",
4582 "t,r,j", tempreg
, tempreg
, (int) BFD_RELOC_LO16
);
4584 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4585 mips_isa
< 3 ? "addu" : "daddu",
4586 "d,v,t", tempreg
, tempreg
, breg
);
4587 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, fmt
, treg
,
4588 (int) BFD_RELOC_LO16
, tempreg
);
4590 else if (mips_pic
== SVR4_PIC
)
4594 /* If this is a reference to an external symbol, we want
4595 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
4596 addu $tempreg,$tempreg,$gp
4597 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
4598 <op> $treg,0($tempreg)
4600 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
4602 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
4603 <op> $treg,0($tempreg)
4604 If there is a base register, we add it to $tempreg before
4605 the <op>. If there is a constant, we stick it in the
4606 <op> instruction. We don't handle constants larger than
4607 16 bits, because we have no way to load the upper 16 bits
4608 (actually, we could handle them for the subset of cases
4609 in which we are not using $at). */
4610 assert (offset_expr
.X_op
== O_symbol
);
4611 expr1
.X_add_number
= offset_expr
.X_add_number
;
4612 offset_expr
.X_add_number
= 0;
4613 if (expr1
.X_add_number
< -0x8000
4614 || expr1
.X_add_number
>= 0x8000)
4615 as_bad ("PIC code offset overflow (max 16 signed bits)");
4616 if (reg_needs_delay (GP
))
4621 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lui", "t,u",
4622 tempreg
, (int) BFD_RELOC_MIPS_GOT_HI16
);
4623 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4624 mips_isa
< 3 ? "addu" : "daddu",
4625 "d,v,t", tempreg
, tempreg
, GP
);
4626 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4627 mips_isa
< 3 ? "lw" : "ld",
4628 "t,o(b)", tempreg
, (int) BFD_RELOC_MIPS_GOT_LO16
,
4630 p
= frag_var (rs_machine_dependent
, 12 + gpdel
, 0,
4631 RELAX_ENCODE (12, 12 + gpdel
, gpdel
, 8 + gpdel
, 0, 0),
4632 offset_expr
.X_add_symbol
, (long) 0, (char *) NULL
);
4635 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
4638 macro_build (p
, &icnt
, &offset_expr
,
4639 mips_isa
< 3 ? "lw" : "ld",
4640 "t,o(b)", tempreg
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
4642 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
4644 macro_build (p
, &icnt
, &offset_expr
,
4645 mips_isa
< 3 ? "addiu" : "daddiu",
4646 "t,r,j", tempreg
, tempreg
, (int) BFD_RELOC_LO16
);
4648 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4649 mips_isa
< 3 ? "addu" : "daddu",
4650 "d,v,t", tempreg
, tempreg
, breg
);
4651 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, fmt
, treg
,
4652 (int) BFD_RELOC_LO16
, tempreg
);
4654 else if (mips_pic
== EMBEDDED_PIC
)
4656 /* If there is no base register, we want
4657 <op> $treg,<sym>($gp) (BFD_RELOC_MIPS_GPREL)
4658 If there is a base register, we want
4659 addu $tempreg,$breg,$gp
4660 <op> $treg,<sym>($tempreg) (BFD_RELOC_MIPS_GPREL)
4662 assert (offset_expr
.X_op
== O_symbol
);
4665 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
4666 treg
, (int) BFD_RELOC_MIPS_GPREL
, GP
);
4671 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4672 mips_isa
< 3 ? "addu" : "daddu",
4673 "d,v,t", tempreg
, breg
, GP
);
4674 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
4675 treg
, (int) BFD_RELOC_MIPS_GPREL
, tempreg
);
4688 load_register (&icnt
, treg
, &imm_expr
, 0);
4692 load_register (&icnt
, treg
, &imm_expr
, 1);
4696 if (imm_expr
.X_op
== O_constant
)
4698 load_register (&icnt
, AT
, &imm_expr
, 0);
4699 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4700 "mtc1", "t,G", AT
, treg
);
4705 assert (offset_expr
.X_op
== O_symbol
4706 && strcmp (segment_name (S_GET_SEGMENT
4707 (offset_expr
.X_add_symbol
)),
4709 && offset_expr
.X_add_number
== 0);
4710 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lwc1", "T,o(b)",
4711 treg
, (int) BFD_RELOC_MIPS_LITERAL
, GP
);
4716 /* We know that sym is in the .rdata section. First we get the
4717 upper 16 bits of the address. */
4718 if (mips_pic
== NO_PIC
)
4720 /* FIXME: This won't work for a 64 bit address. */
4721 macro_build_lui ((char *) NULL
, &icnt
, &offset_expr
, AT
);
4723 else if (mips_pic
== SVR4_PIC
)
4725 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4726 mips_isa
< 3 ? "lw" : "ld",
4727 "t,o(b)", AT
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
4729 else if (mips_pic
== EMBEDDED_PIC
)
4731 /* For embedded PIC we pick up the entire address off $gp in
4732 a single instruction. */
4733 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4734 mips_isa
< 3 ? "addiu" : "daddiu",
4735 "t,r,j", AT
, GP
, (int) BFD_RELOC_MIPS_GPREL
);
4736 offset_expr
.X_op
= O_constant
;
4737 offset_expr
.X_add_number
= 0;
4742 /* Now we load the register(s). */
4744 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "ld", "t,o(b)",
4745 treg
, (int) BFD_RELOC_LO16
, AT
);
4748 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lw", "t,o(b)",
4749 treg
, (int) BFD_RELOC_LO16
, AT
);
4752 /* FIXME: How in the world do we deal with the possible
4754 offset_expr
.X_add_number
+= 4;
4755 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lw", "t,o(b)",
4756 treg
+ 1, (int) BFD_RELOC_LO16
, AT
);
4760 /* To avoid confusion in tc_gen_reloc, we must ensure that this
4761 does not become a variant frag. */
4762 frag_wane (frag_now
);
4768 assert (offset_expr
.X_op
== O_symbol
4769 && offset_expr
.X_add_number
== 0);
4770 s
= segment_name (S_GET_SEGMENT (offset_expr
.X_add_symbol
));
4771 if (strcmp (s
, ".lit8") == 0)
4775 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "ldc1",
4776 "T,o(b)", treg
, (int) BFD_RELOC_MIPS_LITERAL
, GP
);
4780 r
= BFD_RELOC_MIPS_LITERAL
;
4785 assert (strcmp (s
, RDATA_SECTION_NAME
) == 0);
4786 if (mips_pic
== SVR4_PIC
)
4787 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
4788 mips_isa
< 3 ? "lw" : "ld",
4789 "t,o(b)", AT
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
4792 /* FIXME: This won't work for a 64 bit address. */
4793 macro_build_lui ((char *) NULL
, &icnt
, &offset_expr
, AT
);
4798 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "ldc1",
4799 "T,o(b)", treg
, (int) BFD_RELOC_LO16
, AT
);
4801 /* To avoid confusion in tc_gen_reloc, we must ensure
4802 that this does not become a variant frag. */
4803 frag_wane (frag_now
);
4814 /* Even on a big endian machine $fn comes before $fn+1. We have
4815 to adjust when loading from memory. */
4818 assert (mips_isa
< 2);
4819 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lwc1", "T,o(b)",
4820 target_big_endian
? treg
+ 1 : treg
,
4822 /* FIXME: A possible overflow which I don't know how to deal
4824 offset_expr
.X_add_number
+= 4;
4825 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lwc1", "T,o(b)",
4826 target_big_endian
? treg
: treg
+ 1,
4829 /* To avoid confusion in tc_gen_reloc, we must ensure that this
4830 does not become a variant frag. */
4831 frag_wane (frag_now
);
4840 * The MIPS assembler seems to check for X_add_number not
4841 * being double aligned and generating:
4844 * addiu at,at,%lo(foo+1)
4847 * But, the resulting address is the same after relocation so why
4848 * generate the extra instruction?
4895 if (offset_expr
.X_op
!= O_symbol
4896 && offset_expr
.X_op
!= O_constant
)
4898 as_bad ("expression too complex");
4899 offset_expr
.X_op
= O_constant
;
4902 /* Even on a big endian machine $fn comes before $fn+1. We have
4903 to adjust when loading from memory. We set coproc if we must
4904 load $fn+1 first. */
4905 if (! target_big_endian
)
4908 if (mips_pic
== NO_PIC
4909 || offset_expr
.X_op
== O_constant
)
4911 /* If this is a reference to a GP relative symbol, we want
4912 <op> $treg,<sym>($gp) (BFD_RELOC_MIPS_GPREL)
4913 <op> $treg+1,<sym>+4($gp) (BFD_RELOC_MIPS_GPREL)
4914 If we have a base register, we use this
4916 <op> $treg,<sym>($at) (BFD_RELOC_MIPS_GPREL)
4917 <op> $treg+1,<sym>+4($at) (BFD_RELOC_MIPS_GPREL)
4918 If this is not a GP relative symbol, we want
4919 lui $at,<sym> (BFD_RELOC_HI16_S)
4920 <op> $treg,<sym>($at) (BFD_RELOC_LO16)
4921 <op> $treg+1,<sym>+4($at) (BFD_RELOC_LO16)
4922 If there is a base register, we add it to $at after the
4923 lui instruction. If there is a constant, we always use
4925 if ((valueT
) offset_expr
.X_add_number
>= MAX_GPREL_OFFSET
4926 || nopic_need_relax (offset_expr
.X_add_symbol
))
4945 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
4946 mips_isa
< 3 ? "addu" : "daddu",
4947 "d,v,t", AT
, breg
, GP
);
4953 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
4954 coproc
? treg
+ 1 : treg
,
4955 (int) BFD_RELOC_MIPS_GPREL
, tempreg
);
4956 offset_expr
.X_add_number
+= 4;
4958 /* Set mips_optimize to 2 to avoid inserting an
4960 hold_mips_optimize
= mips_optimize
;
4962 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
4963 coproc
? treg
: treg
+ 1,
4964 (int) BFD_RELOC_MIPS_GPREL
, tempreg
);
4965 mips_optimize
= hold_mips_optimize
;
4967 p
= frag_var (rs_machine_dependent
, 12 + off
, 0,
4968 RELAX_ENCODE (8 + off
, 12 + off
, 0, 4 + off
, 1,
4969 used_at
&& mips_noat
),
4970 offset_expr
.X_add_symbol
, (long) 0,
4973 /* We just generated two relocs. When tc_gen_reloc
4974 handles this case, it will skip the first reloc and
4975 handle the second. The second reloc already has an
4976 extra addend of 4, which we added above. We must
4977 subtract it out, and then subtract another 4 to make
4978 the first reloc come out right. The second reloc
4979 will come out right because we are going to add 4 to
4980 offset_expr when we build its instruction below. */
4981 offset_expr
.X_add_number
-= 8;
4982 offset_expr
.X_op
= O_constant
;
4984 macro_build_lui (p
, &icnt
, &offset_expr
, AT
);
4989 macro_build (p
, &icnt
, (expressionS
*) NULL
,
4990 mips_isa
< 3 ? "addu" : "daddu",
4991 "d,v,t", AT
, breg
, AT
);
4995 macro_build (p
, &icnt
, &offset_expr
, s
, fmt
,
4996 coproc
? treg
+ 1 : treg
,
4997 (int) BFD_RELOC_LO16
, AT
);
5000 /* FIXME: How do we handle overflow here? */
5001 offset_expr
.X_add_number
+= 4;
5002 macro_build (p
, &icnt
, &offset_expr
, s
, fmt
,
5003 coproc
? treg
: treg
+ 1,
5004 (int) BFD_RELOC_LO16
, AT
);
5006 else if (mips_pic
== SVR4_PIC
&& ! mips_big_got
)
5010 /* If this is a reference to an external symbol, we want
5011 lw $at,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
5016 lw $at,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
5018 <op> $treg,<sym>($at) (BFD_RELOC_LO16)
5019 <op> $treg+1,<sym>+4($at) (BFD_RELOC_LO16)
5020 If there is a base register we add it to $at before the
5021 lwc1 instructions. If there is a constant we include it
5022 in the lwc1 instructions. */
5024 expr1
.X_add_number
= offset_expr
.X_add_number
;
5025 offset_expr
.X_add_number
= 0;
5026 if (expr1
.X_add_number
< -0x8000
5027 || expr1
.X_add_number
>= 0x8000 - 4)
5028 as_bad ("PIC code offset overflow (max 16 signed bits)");
5033 frag_grow (24 + off
);
5034 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
5035 mips_isa
< 3 ? "lw" : "ld",
5036 "t,o(b)", AT
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
5037 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
, "nop", "");
5039 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5040 mips_isa
< 3 ? "addu" : "daddu",
5041 "d,v,t", AT
, breg
, AT
);
5042 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, fmt
,
5043 coproc
? treg
+ 1 : treg
,
5044 (int) BFD_RELOC_LO16
, AT
);
5045 expr1
.X_add_number
+= 4;
5047 /* Set mips_optimize to 2 to avoid inserting an undesired
5049 hold_mips_optimize
= mips_optimize
;
5051 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, fmt
,
5052 coproc
? treg
: treg
+ 1,
5053 (int) BFD_RELOC_LO16
, AT
);
5054 mips_optimize
= hold_mips_optimize
;
5056 (void) frag_var (rs_machine_dependent
, 0, 0,
5057 RELAX_ENCODE (0, 0, -16 - off
, -8, 1, 0),
5058 offset_expr
.X_add_symbol
, (long) 0,
5061 else if (mips_pic
== SVR4_PIC
)
5065 /* If this is a reference to an external symbol, we want
5066 lui $at,<sym> (BFD_RELOC_MIPS_GOT_HI16)
5068 lw $at,<sym>($at) (BFD_RELOC_MIPS_GOT_LO16)
5073 lw $at,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
5075 <op> $treg,<sym>($at) (BFD_RELOC_LO16)
5076 <op> $treg+1,<sym>+4($at) (BFD_RELOC_LO16)
5077 If there is a base register we add it to $at before the
5078 lwc1 instructions. If there is a constant we include it
5079 in the lwc1 instructions. */
5081 expr1
.X_add_number
= offset_expr
.X_add_number
;
5082 offset_expr
.X_add_number
= 0;
5083 if (expr1
.X_add_number
< -0x8000
5084 || expr1
.X_add_number
>= 0x8000 - 4)
5085 as_bad ("PIC code offset overflow (max 16 signed bits)");
5086 if (reg_needs_delay (GP
))
5095 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lui", "t,u",
5096 AT
, (int) BFD_RELOC_MIPS_GOT_HI16
);
5097 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5098 mips_isa
< 3 ? "addu" : "daddu",
5099 "d,v,t", AT
, AT
, GP
);
5100 macro_build ((char *) NULL
, &icnt
, &offset_expr
,
5101 mips_isa
< 3 ? "lw" : "ld",
5102 "t,o(b)", AT
, (int) BFD_RELOC_MIPS_GOT_LO16
, AT
);
5103 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
, "nop", "");
5105 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5106 mips_isa
< 3 ? "addu" : "daddu",
5107 "d,v,t", AT
, breg
, AT
);
5108 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, fmt
,
5109 coproc
? treg
+ 1 : treg
,
5110 (int) BFD_RELOC_LO16
, AT
);
5111 expr1
.X_add_number
+= 4;
5113 /* Set mips_optimize to 2 to avoid inserting an undesired
5115 hold_mips_optimize
= mips_optimize
;
5117 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, fmt
,
5118 coproc
? treg
: treg
+ 1,
5119 (int) BFD_RELOC_LO16
, AT
);
5120 mips_optimize
= hold_mips_optimize
;
5121 expr1
.X_add_number
-= 4;
5123 p
= frag_var (rs_machine_dependent
, 16 + gpdel
+ off
, 0,
5124 RELAX_ENCODE (24 + off
, 16 + gpdel
+ off
, gpdel
,
5125 8 + gpdel
+ off
, 1, 0),
5126 offset_expr
.X_add_symbol
, (long) 0,
5130 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
5133 macro_build (p
, &icnt
, &offset_expr
,
5134 mips_isa
< 3 ? "lw" : "ld",
5135 "t,o(b)", AT
, (int) BFD_RELOC_MIPS_GOT16
, GP
);
5137 macro_build (p
, &icnt
, (expressionS
*) NULL
, "nop", "");
5141 macro_build (p
, &icnt
, (expressionS
*) NULL
,
5142 mips_isa
< 3 ? "addu" : "daddu",
5143 "d,v,t", AT
, breg
, AT
);
5146 macro_build (p
, &icnt
, &expr1
, s
, fmt
,
5147 coproc
? treg
+ 1 : treg
,
5148 (int) BFD_RELOC_LO16
, AT
);
5150 expr1
.X_add_number
+= 4;
5152 /* Set mips_optimize to 2 to avoid inserting an undesired
5154 hold_mips_optimize
= mips_optimize
;
5156 macro_build (p
, &icnt
, &expr1
, s
, fmt
,
5157 coproc
? treg
: treg
+ 1,
5158 (int) BFD_RELOC_LO16
, AT
);
5159 mips_optimize
= hold_mips_optimize
;
5161 else if (mips_pic
== EMBEDDED_PIC
)
5163 /* If there is no base register, we use
5164 <op> $treg,<sym>($gp) (BFD_RELOC_MIPS_GPREL)
5165 <op> $treg+1,<sym>+4($gp) (BFD_RELOC_MIPS_GPREL)
5166 If we have a base register, we use
5168 <op> $treg,<sym>($at) (BFD_RELOC_MIPS_GPREL)
5169 <op> $treg+1,<sym>+4($at) (BFD_RELOC_MIPS_GPREL)
5178 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5179 mips_isa
< 3 ? "addu" : "daddu",
5180 "d,v,t", AT
, breg
, GP
);
5185 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
5186 coproc
? treg
+ 1 : treg
,
5187 (int) BFD_RELOC_MIPS_GPREL
, tempreg
);
5188 offset_expr
.X_add_number
+= 4;
5189 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, fmt
,
5190 coproc
? treg
: treg
+ 1,
5191 (int) BFD_RELOC_MIPS_GPREL
, tempreg
);
5207 assert (mips_isa
< 3);
5208 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, "t,o(b)", treg
,
5209 (int) BFD_RELOC_LO16
, breg
);
5210 offset_expr
.X_add_number
+= 4;
5211 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, "t,o(b)", treg
+ 1,
5212 (int) BFD_RELOC_LO16
, breg
);
5214 #ifdef LOSING_COMPILER
5220 as_warn ("Macro used $at after \".set noat\"");
5225 struct mips_cl_insn
*ip
;
5227 register int treg
, sreg
, dreg
, breg
;
5242 bfd_reloc_code_real_type r
;
5245 treg
= (ip
->insn_opcode
>> 16) & 0x1f;
5246 dreg
= (ip
->insn_opcode
>> 11) & 0x1f;
5247 sreg
= breg
= (ip
->insn_opcode
>> 21) & 0x1f;
5248 mask
= ip
->insn_mo
->mask
;
5250 expr1
.X_op
= O_constant
;
5251 expr1
.X_op_symbol
= NULL
;
5252 expr1
.X_add_symbol
= NULL
;
5253 expr1
.X_add_number
= 1;
5257 #endif /* LOSING_COMPILER */
5262 macro_build ((char *) NULL
, &icnt
, NULL
,
5263 dbl
? "dmultu" : "multu",
5265 macro_build ((char *) NULL
, &icnt
, NULL
, "mflo", "d", dreg
);
5271 /* The MIPS assembler some times generates shifts and adds. I'm
5272 not trying to be that fancy. GCC should do this for us
5274 load_register (&icnt
, AT
, &imm_expr
, dbl
);
5275 macro_build ((char *) NULL
, &icnt
, NULL
,
5276 dbl
? "dmult" : "mult",
5278 macro_build ((char *) NULL
, &icnt
, NULL
, "mflo", "d", dreg
);
5284 mips_emit_delays (true);
5286 mips_any_noreorder
= 1;
5287 macro_build ((char *) NULL
, &icnt
, NULL
,
5288 dbl
? "dmult" : "mult",
5290 macro_build ((char *) NULL
, &icnt
, NULL
, "mflo", "d", dreg
);
5291 macro_build ((char *) NULL
, &icnt
, NULL
,
5292 dbl
? "dsra32" : "sra",
5293 "d,w,<", dreg
, dreg
, 31);
5294 macro_build ((char *) NULL
, &icnt
, NULL
, "mfhi", "d", AT
);
5296 macro_build ((char *) NULL
, &icnt
, NULL
, "tne", "s,t", dreg
, AT
);
5299 expr1
.X_add_number
= 8;
5300 macro_build ((char *) NULL
, &icnt
, &expr1
, "beq", "s,t,p", dreg
, AT
);
5301 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "", 0);
5302 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "c", 6);
5305 macro_build ((char *) NULL
, &icnt
, NULL
, "mflo", "d", dreg
);
5311 mips_emit_delays (true);
5313 mips_any_noreorder
= 1;
5314 macro_build ((char *) NULL
, &icnt
, NULL
,
5315 dbl
? "dmultu" : "multu",
5317 macro_build ((char *) NULL
, &icnt
, NULL
, "mfhi", "d", AT
);
5318 macro_build ((char *) NULL
, &icnt
, NULL
, "mflo", "d", dreg
);
5320 macro_build ((char *) NULL
, &icnt
, NULL
, "tne", "s,t", AT
, 0);
5323 expr1
.X_add_number
= 8;
5324 macro_build ((char *) NULL
, &icnt
, &expr1
, "beq", "s,t,p", AT
, 0);
5325 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "", 0);
5326 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "c", 6);
5332 macro_build ((char *) NULL
, &icnt
, NULL
, "subu", "d,v,t", AT
, 0, treg
);
5333 macro_build ((char *) NULL
, &icnt
, NULL
, "srlv", "d,t,s", AT
, sreg
, AT
);
5334 macro_build ((char *) NULL
, &icnt
, NULL
, "sllv", "d,t,s", dreg
, sreg
,
5336 macro_build ((char *) NULL
, &icnt
, NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
5340 macro_build ((char *) NULL
, &icnt
, NULL
, "sll", "d,w,<", AT
, sreg
,
5341 (int) (imm_expr
.X_add_number
& 0x1f));
5342 macro_build ((char *) NULL
, &icnt
, NULL
, "srl", "d,w,<", dreg
, sreg
,
5343 (int) ((0 - imm_expr
.X_add_number
) & 0x1f));
5344 macro_build ((char *) NULL
, &icnt
, NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
5348 macro_build ((char *) NULL
, &icnt
, NULL
, "subu", "d,v,t", AT
, 0, treg
);
5349 macro_build ((char *) NULL
, &icnt
, NULL
, "sllv", "d,t,s", AT
, sreg
, AT
);
5350 macro_build ((char *) NULL
, &icnt
, NULL
, "srlv", "d,t,s", dreg
, sreg
,
5352 macro_build ((char *) NULL
, &icnt
, NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
5356 macro_build ((char *) NULL
, &icnt
, NULL
, "srl", "d,w,<", AT
, sreg
,
5357 (int) (imm_expr
.X_add_number
& 0x1f));
5358 macro_build ((char *) NULL
, &icnt
, NULL
, "sll", "d,w,<", dreg
, sreg
,
5359 (int) ((0 - imm_expr
.X_add_number
) & 0x1f));
5360 macro_build ((char *) NULL
, &icnt
, NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
5364 assert (mips_isa
< 2);
5365 /* Even on a big endian machine $fn comes before $fn+1. We have
5366 to adjust when storing to memory. */
5367 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "swc1", "T,o(b)",
5368 target_big_endian
? treg
+ 1 : treg
,
5369 (int) BFD_RELOC_LO16
, breg
);
5370 offset_expr
.X_add_number
+= 4;
5371 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "swc1", "T,o(b)",
5372 target_big_endian
? treg
: treg
+ 1,
5373 (int) BFD_RELOC_LO16
, breg
);
5378 macro_build ((char *) NULL
, &icnt
, &expr1
, "sltiu", "t,r,j", dreg
,
5379 treg
, (int) BFD_RELOC_LO16
);
5381 macro_build ((char *) NULL
, &icnt
, &expr1
, "sltiu", "t,r,j", dreg
,
5382 sreg
, (int) BFD_RELOC_LO16
);
5385 macro_build ((char *) NULL
, &icnt
, NULL
, "xor", "d,v,t", dreg
,
5387 macro_build ((char *) NULL
, &icnt
, &expr1
, "sltiu", "t,r,j", dreg
,
5388 dreg
, (int) BFD_RELOC_LO16
);
5393 if (imm_expr
.X_add_number
== 0)
5395 macro_build ((char *) NULL
, &icnt
, &expr1
, "sltiu", "t,r,j", dreg
,
5396 sreg
, (int) BFD_RELOC_LO16
);
5401 as_warn ("Instruction %s: result is always false",
5403 macro_build ((char *) NULL
, &icnt
, NULL
, "move", "d,s", dreg
, 0);
5406 if (imm_expr
.X_add_number
>= 0 && imm_expr
.X_add_number
< 0x10000)
5408 macro_build ((char *) NULL
, &icnt
, &imm_expr
, "xori", "t,r,i", dreg
,
5409 sreg
, (int) BFD_RELOC_LO16
);
5412 else if (imm_expr
.X_add_number
> -0x8000 && imm_expr
.X_add_number
< 0)
5414 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
5415 macro_build ((char *) NULL
, &icnt
, &imm_expr
,
5416 mips_isa
< 3 ? "addiu" : "daddiu",
5417 "t,r,j", dreg
, sreg
,
5418 (int) BFD_RELOC_LO16
);
5423 load_register (&icnt
, AT
, &imm_expr
, 0);
5424 macro_build ((char *) NULL
, &icnt
, NULL
, "xor", "d,v,t", dreg
,
5428 macro_build ((char *) NULL
, &icnt
, &expr1
, "sltiu", "t,r,j", dreg
, dreg
,
5429 (int) BFD_RELOC_LO16
);
5434 case M_SGE
: /* sreg >= treg <==> not (sreg < treg) */
5440 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "d,v,t", dreg
, sreg
, treg
);
5441 macro_build ((char *) NULL
, &icnt
, &expr1
, "xori", "t,r,i", dreg
, dreg
,
5442 (int) BFD_RELOC_LO16
);
5445 case M_SGE_I
: /* sreg >= I <==> not (sreg < I) */
5447 if (imm_expr
.X_add_number
>= -0x8000 && imm_expr
.X_add_number
< 0x8000)
5449 macro_build ((char *) NULL
, &icnt
, &expr1
,
5450 mask
== M_SGE_I
? "slti" : "sltiu",
5451 "t,r,j", dreg
, sreg
, (int) BFD_RELOC_LO16
);
5456 load_register (&icnt
, AT
, &imm_expr
, 0);
5457 macro_build ((char *) NULL
, &icnt
, NULL
,
5458 mask
== M_SGE_I
? "slt" : "sltu",
5459 "d,v,t", dreg
, sreg
, AT
);
5462 macro_build ((char *) NULL
, &icnt
, &expr1
, "xori", "t,r,i", dreg
, dreg
,
5463 (int) BFD_RELOC_LO16
);
5468 case M_SGT
: /* sreg > treg <==> treg < sreg */
5474 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "d,v,t", dreg
, treg
, sreg
);
5477 case M_SGT_I
: /* sreg > I <==> I < sreg */
5483 load_register (&icnt
, AT
, &imm_expr
, 0);
5484 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "d,v,t", dreg
, AT
, sreg
);
5487 case M_SLE
: /* sreg <= treg <==> treg >= sreg <==> not (treg < sreg) */
5493 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "d,v,t", dreg
, treg
, sreg
);
5494 macro_build ((char *) NULL
, &icnt
, &expr1
, "xori", "t,r,i", dreg
, dreg
,
5495 (int) BFD_RELOC_LO16
);
5498 case M_SLE_I
: /* sreg <= I <==> I >= sreg <==> not (I < sreg) */
5504 load_register (&icnt
, AT
, &imm_expr
, 0);
5505 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "d,v,t", dreg
, AT
, sreg
);
5506 macro_build ((char *) NULL
, &icnt
, &expr1
, "xori", "t,r,i", dreg
, dreg
,
5507 (int) BFD_RELOC_LO16
);
5511 if (imm_expr
.X_add_number
>= -0x8000 && imm_expr
.X_add_number
< 0x8000)
5513 macro_build ((char *) NULL
, &icnt
, &imm_expr
, "slti", "t,r,j",
5514 dreg
, sreg
, (int) BFD_RELOC_LO16
);
5517 load_register (&icnt
, AT
, &imm_expr
, 0);
5518 macro_build ((char *) NULL
, &icnt
, NULL
, "slt", "d,v,t", dreg
, sreg
, AT
);
5522 if (imm_expr
.X_add_number
>= -0x8000 && imm_expr
.X_add_number
< 0x8000)
5524 macro_build ((char *) NULL
, &icnt
, &imm_expr
, "sltiu", "t,r,j",
5525 dreg
, sreg
, (int) BFD_RELOC_LO16
);
5528 load_register (&icnt
, AT
, &imm_expr
, 0);
5529 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", dreg
, sreg
,
5535 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", dreg
, 0,
5538 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", dreg
, 0,
5542 macro_build ((char *) NULL
, &icnt
, NULL
, "xor", "d,v,t", dreg
,
5544 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", dreg
, 0,
5550 if (imm_expr
.X_add_number
== 0)
5552 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", dreg
, 0,
5558 as_warn ("Instruction %s: result is always true",
5560 macro_build ((char *) NULL
, &icnt
, &expr1
,
5561 mips_isa
< 3 ? "addiu" : "daddiu",
5562 "t,r,j", dreg
, 0, (int) BFD_RELOC_LO16
);
5565 if (imm_expr
.X_add_number
>= 0 && imm_expr
.X_add_number
< 0x10000)
5567 macro_build ((char *) NULL
, &icnt
, &imm_expr
, "xori", "t,r,i",
5568 dreg
, sreg
, (int) BFD_RELOC_LO16
);
5571 else if (imm_expr
.X_add_number
> -0x8000 && imm_expr
.X_add_number
< 0)
5573 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
5574 macro_build ((char *) NULL
, &icnt
, &imm_expr
,
5575 mips_isa
< 3 ? "addiu" : "daddiu",
5576 "t,r,j", dreg
, sreg
, (int) BFD_RELOC_LO16
);
5581 load_register (&icnt
, AT
, &imm_expr
, 0);
5582 macro_build ((char *) NULL
, &icnt
, NULL
, "xor", "d,v,t", dreg
,
5586 macro_build ((char *) NULL
, &icnt
, NULL
, "sltu", "d,v,t", dreg
, 0, dreg
);
5594 if (imm_expr
.X_add_number
> -0x8000 && imm_expr
.X_add_number
<= 0x8000)
5596 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
5597 macro_build ((char *) NULL
, &icnt
, &imm_expr
,
5598 dbl
? "daddi" : "addi",
5599 "t,r,j", dreg
, sreg
, (int) BFD_RELOC_LO16
);
5602 load_register (&icnt
, AT
, &imm_expr
, dbl
);
5603 macro_build ((char *) NULL
, &icnt
, NULL
,
5604 dbl
? "dsub" : "sub",
5605 "d,v,t", dreg
, sreg
, AT
);
5611 if (imm_expr
.X_add_number
> -0x8000 && imm_expr
.X_add_number
<= 0x8000)
5613 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
5614 macro_build ((char *) NULL
, &icnt
, &imm_expr
,
5615 dbl
? "daddiu" : "addiu",
5616 "t,r,j", dreg
, sreg
, (int) BFD_RELOC_LO16
);
5619 load_register (&icnt
, AT
, &imm_expr
, dbl
);
5620 macro_build ((char *) NULL
, &icnt
, NULL
,
5621 dbl
? "dsubu" : "subu",
5622 "d,v,t", dreg
, sreg
, AT
);
5643 load_register (&icnt
, AT
, &imm_expr
, 0);
5644 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "s,t", sreg
, AT
);
5649 assert (mips_isa
< 2);
5650 sreg
= (ip
->insn_opcode
>> 11) & 0x1f; /* floating reg */
5651 dreg
= (ip
->insn_opcode
>> 06) & 0x1f; /* floating reg */
5654 * Is the double cfc1 instruction a bug in the mips assembler;
5655 * or is there a reason for it?
5657 mips_emit_delays (true);
5659 mips_any_noreorder
= 1;
5660 macro_build ((char *) NULL
, &icnt
, NULL
, "cfc1", "t,G", treg
, 31);
5661 macro_build ((char *) NULL
, &icnt
, NULL
, "cfc1", "t,G", treg
, 31);
5662 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "");
5663 expr1
.X_add_number
= 3;
5664 macro_build ((char *) NULL
, &icnt
, &expr1
, "ori", "t,r,i", AT
, treg
,
5665 (int) BFD_RELOC_LO16
);
5666 expr1
.X_add_number
= 2;
5667 macro_build ((char *) NULL
, &icnt
, &expr1
, "xori", "t,r,i", AT
, AT
,
5668 (int) BFD_RELOC_LO16
);
5669 macro_build ((char *) NULL
, &icnt
, NULL
, "ctc1", "t,G", AT
, 31);
5670 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "");
5671 macro_build ((char *) NULL
, &icnt
, NULL
,
5672 mask
== M_TRUNCWD
? "cvt.w.d" : "cvt.w.s", "D,S", dreg
, sreg
);
5673 macro_build ((char *) NULL
, &icnt
, NULL
, "ctc1", "t,G", treg
, 31);
5674 macro_build ((char *) NULL
, &icnt
, NULL
, "nop", "");
5684 if (offset_expr
.X_add_number
>= 0x7fff)
5685 as_bad ("operand overflow");
5686 /* avoid load delay */
5687 if (! target_big_endian
)
5688 offset_expr
.X_add_number
+= 1;
5689 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, "t,o(b)", treg
,
5690 (int) BFD_RELOC_LO16
, breg
);
5691 if (! target_big_endian
)
5692 offset_expr
.X_add_number
-= 1;
5694 offset_expr
.X_add_number
+= 1;
5695 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "lbu", "t,o(b)", AT
,
5696 (int) BFD_RELOC_LO16
, breg
);
5697 macro_build ((char *) NULL
, &icnt
, NULL
, "sll", "d,w,<", treg
, treg
, 8);
5698 macro_build ((char *) NULL
, &icnt
, NULL
, "or", "d,v,t", treg
, treg
, AT
);
5711 if (offset_expr
.X_add_number
>= 0x8000 - off
)
5712 as_bad ("operand overflow");
5713 if (! target_big_endian
)
5714 offset_expr
.X_add_number
+= off
;
5715 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, "t,o(b)", treg
,
5716 (int) BFD_RELOC_LO16
, breg
);
5717 if (! target_big_endian
)
5718 offset_expr
.X_add_number
-= off
;
5720 offset_expr
.X_add_number
+= off
;
5721 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s2
, "t,o(b)", treg
,
5722 (int) BFD_RELOC_LO16
, breg
);
5735 load_address (&icnt
, AT
, &offset_expr
);
5737 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5738 mips_isa
< 3 ? "addu" : "daddu",
5739 "d,v,t", AT
, AT
, breg
);
5740 if (! target_big_endian
)
5741 expr1
.X_add_number
= off
;
5743 expr1
.X_add_number
= 0;
5744 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, "t,o(b)", treg
,
5745 (int) BFD_RELOC_LO16
, AT
);
5746 if (! target_big_endian
)
5747 expr1
.X_add_number
= 0;
5749 expr1
.X_add_number
= off
;
5750 macro_build ((char *) NULL
, &icnt
, &expr1
, s2
, "t,o(b)", treg
,
5751 (int) BFD_RELOC_LO16
, AT
);
5756 load_address (&icnt
, AT
, &offset_expr
);
5758 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5759 mips_isa
< 3 ? "addu" : "daddu",
5760 "d,v,t", AT
, AT
, breg
);
5761 if (target_big_endian
)
5762 expr1
.X_add_number
= 0;
5763 macro_build ((char *) NULL
, &icnt
, &expr1
,
5764 mask
== M_ULH_A
? "lb" : "lbu", "t,o(b)", treg
,
5765 (int) BFD_RELOC_LO16
, AT
);
5766 if (target_big_endian
)
5767 expr1
.X_add_number
= 1;
5769 expr1
.X_add_number
= 0;
5770 macro_build ((char *) NULL
, &icnt
, &expr1
, "lbu", "t,o(b)", AT
,
5771 (int) BFD_RELOC_LO16
, AT
);
5772 macro_build ((char *) NULL
, &icnt
, NULL
, "sll", "d,w,<", treg
,
5774 macro_build ((char *) NULL
, &icnt
, NULL
, "or", "d,v,t", treg
,
5779 if (offset_expr
.X_add_number
>= 0x7fff)
5780 as_bad ("operand overflow");
5781 if (target_big_endian
)
5782 offset_expr
.X_add_number
+= 1;
5783 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "sb", "t,o(b)", treg
,
5784 (int) BFD_RELOC_LO16
, breg
);
5785 macro_build ((char *) NULL
, &icnt
, NULL
, "srl", "d,w,<", AT
, treg
, 8);
5786 if (target_big_endian
)
5787 offset_expr
.X_add_number
-= 1;
5789 offset_expr
.X_add_number
+= 1;
5790 macro_build ((char *) NULL
, &icnt
, &offset_expr
, "sb", "t,o(b)", AT
,
5791 (int) BFD_RELOC_LO16
, breg
);
5804 if (offset_expr
.X_add_number
>= 0x8000 - off
)
5805 as_bad ("operand overflow");
5806 if (! target_big_endian
)
5807 offset_expr
.X_add_number
+= off
;
5808 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s
, "t,o(b)", treg
,
5809 (int) BFD_RELOC_LO16
, breg
);
5810 if (! target_big_endian
)
5811 offset_expr
.X_add_number
-= off
;
5813 offset_expr
.X_add_number
+= off
;
5814 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s2
, "t,o(b)", treg
,
5815 (int) BFD_RELOC_LO16
, breg
);
5828 load_address (&icnt
, AT
, &offset_expr
);
5830 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5831 mips_isa
< 3 ? "addu" : "daddu",
5832 "d,v,t", AT
, AT
, breg
);
5833 if (! target_big_endian
)
5834 expr1
.X_add_number
= off
;
5836 expr1
.X_add_number
= 0;
5837 macro_build ((char *) NULL
, &icnt
, &expr1
, s
, "t,o(b)", treg
,
5838 (int) BFD_RELOC_LO16
, AT
);
5839 if (! target_big_endian
)
5840 expr1
.X_add_number
= 0;
5842 expr1
.X_add_number
= off
;
5843 macro_build ((char *) NULL
, &icnt
, &expr1
, s2
, "t,o(b)", treg
,
5844 (int) BFD_RELOC_LO16
, AT
);
5848 load_address (&icnt
, AT
, &offset_expr
);
5850 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
5851 mips_isa
< 3 ? "addu" : "daddu",
5852 "d,v,t", AT
, AT
, breg
);
5853 if (! target_big_endian
)
5854 expr1
.X_add_number
= 0;
5855 macro_build ((char *) NULL
, &icnt
, &expr1
, "sb", "t,o(b)", treg
,
5856 (int) BFD_RELOC_LO16
, AT
);
5857 macro_build ((char *) NULL
, &icnt
, NULL
, "srl", "d,w,<", treg
,
5859 if (! target_big_endian
)
5860 expr1
.X_add_number
= 1;
5862 expr1
.X_add_number
= 0;
5863 macro_build ((char *) NULL
, &icnt
, &expr1
, "sb", "t,o(b)", treg
,
5864 (int) BFD_RELOC_LO16
, AT
);
5865 if (! target_big_endian
)
5866 expr1
.X_add_number
= 0;
5868 expr1
.X_add_number
= 1;
5869 macro_build ((char *) NULL
, &icnt
, &expr1
, "lbu", "t,o(b)", AT
,
5870 (int) BFD_RELOC_LO16
, AT
);
5871 macro_build ((char *) NULL
, &icnt
, NULL
, "sll", "d,w,<", treg
,
5873 macro_build ((char *) NULL
, &icnt
, NULL
, "or", "d,v,t", treg
,
5878 as_bad ("Macro %s not implemented yet", ip
->insn_mo
->name
);
5882 as_warn ("Macro used $at after \".set noat\"");
5885 /* Implement macros in mips16 mode. */
5889 struct mips_cl_insn
*ip
;
5892 int xreg
, yreg
, zreg
, tmp
;
5896 const char *s
, *s2
, *s3
;
5898 mask
= ip
->insn_mo
->mask
;
5900 xreg
= (ip
->insn_opcode
>> MIPS16OP_SH_RX
) & MIPS16OP_MASK_RX
;
5901 yreg
= (ip
->insn_opcode
>> MIPS16OP_SH_RY
) & MIPS16OP_MASK_RY
;
5902 zreg
= (ip
->insn_opcode
>> MIPS16OP_SH_RZ
) & MIPS16OP_MASK_RZ
;
5906 expr1
.X_op
= O_constant
;
5907 expr1
.X_op_symbol
= NULL
;
5908 expr1
.X_add_symbol
= NULL
;
5909 expr1
.X_add_number
= 1;
5928 mips_emit_delays (true);
5930 mips_any_noreorder
= 1;
5931 macro_build ((char *) NULL
, &icnt
, NULL
,
5932 dbl
? "ddiv" : "div",
5933 "0,x,y", xreg
, yreg
);
5934 expr1
.X_add_number
= 2;
5935 macro_build ((char *) NULL
, &icnt
, &expr1
, "bnez", "x,p", yreg
);
5936 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "6", 7);
5937 /* FIXME: The normal code checks for of -1 / -0x80000000 here,
5938 since that causes an overflow. We should do that as well,
5939 but I don't see how to do the comparisons without a temporary
5942 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "x", zreg
);
5961 mips_emit_delays (true);
5963 mips_any_noreorder
= 1;
5964 macro_build ((char *) NULL
, &icnt
, NULL
, s
, "0,x,y", xreg
, yreg
);
5965 expr1
.X_add_number
= 2;
5966 macro_build ((char *) NULL
, &icnt
, &expr1
, "bnez", "x,p", yreg
);
5967 macro_build ((char *) NULL
, &icnt
, NULL
, "break", "6", 7);
5969 macro_build ((char *) NULL
, &icnt
, NULL
, s2
, "x", zreg
);
5977 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
5978 macro_build ((char *) NULL
, &icnt
, &imm_expr
,
5979 dbl
? "daddiu" : "addiu",
5980 "y,x,4", yreg
, xreg
);
5984 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
5985 macro_build ((char *) NULL
, &icnt
, &imm_expr
, "addiu",
5990 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
5991 macro_build ((char *) NULL
, &icnt
, &imm_expr
, "daddiu",
6014 goto do_reverse_branch
;
6018 goto do_reverse_branch
;
6030 goto do_reverse_branch
;
6041 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
, s
, "x,y",
6043 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s2
, "p");
6070 goto do_addone_branch_i
;
6075 goto do_addone_branch_i
;
6090 goto do_addone_branch_i
;
6097 ++imm_expr
.X_add_number
;
6100 macro_build ((char *) NULL
, &icnt
, &imm_expr
, s
, s3
, xreg
);
6101 macro_build ((char *) NULL
, &icnt
, &offset_expr
, s2
, "p");
6105 expr1
.X_add_number
= 0;
6106 macro_build ((char *) NULL
, &icnt
, &expr1
, "slti", "x,8", yreg
);
6108 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
6109 "move", "y,X", xreg
, yreg
);
6110 expr1
.X_add_number
= 2;
6111 macro_build ((char *) NULL
, &icnt
, &expr1
, "bteqz", "p");
6112 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
6113 "neg", "x,w", xreg
, xreg
);
6117 /* This routine assembles an instruction into its binary format. As a
6118 side effect, it sets one of the global variables imm_reloc or
6119 offset_reloc to the type of relocation to do if one of the operands
6120 is an address expression. */
6125 struct mips_cl_insn
*ip
;
6130 struct mips_opcode
*insn
;
6133 unsigned int lastregno
= 0;
6138 for (s
= str
; islower (*s
) || (*s
>= '0' && *s
<= '3') || *s
== '6' || *s
== '.'; ++s
)
6150 as_fatal ("Unknown opcode: `%s'", str
);
6152 if ((insn
= (struct mips_opcode
*) hash_find (op_hash
, str
)) == NULL
)
6154 insn_error
= "unrecognized opcode";
6162 assert (strcmp (insn
->name
, str
) == 0);
6164 if (insn
->pinfo
== INSN_MACRO
)
6165 insn_isa
= insn
->match
;
6166 else if ((insn
->pinfo
& INSN_ISA
) == INSN_ISA2
)
6168 else if ((insn
->pinfo
& INSN_ISA
) == INSN_ISA3
)
6170 else if ((insn
->pinfo
& INSN_ISA
) == INSN_ISA4
)
6175 if (insn_isa
> mips_isa
6176 || (insn
->pinfo
!= INSN_MACRO
6177 && (((insn
->pinfo
& INSN_ISA
) == INSN_4650
6179 || ((insn
->pinfo
& INSN_ISA
) == INSN_4010
6181 || ((insn
->pinfo
& INSN_ISA
) == INSN_4100
6183 /* start-sanitize-r5900 */
6184 || ((insn
->pinfo
& INSN_ISA
) == INSN_5900
6186 /* end-sanitize-r5900 */
6189 if (insn
+ 1 < &mips_opcodes
[NUMOPCODES
]
6190 && strcmp (insn
->name
, insn
[1].name
) == 0)
6195 if (insn_isa
<= mips_isa
)
6196 insn_error
= "opcode not supported on this processor";
6199 static char buf
[100];
6201 sprintf (buf
, "opcode requires -mips%d or greater", insn_isa
);
6208 ip
->insn_opcode
= insn
->match
;
6209 for (args
= insn
->args
;; ++args
)
6215 case '\0': /* end of args */
6228 ip
->insn_opcode
|= lastregno
<< 21;
6233 ip
->insn_opcode
|= lastregno
<< 16;
6237 ip
->insn_opcode
|= lastregno
<< 11;
6243 /* handle optional base register.
6244 Either the base register is omitted or
6245 we must have a left paren. */
6246 /* this is dependent on the next operand specifier
6247 is a 'b' for base register */
6248 assert (args
[1] == 'b');
6252 case ')': /* these must match exactly */
6257 case '<': /* must be at least one digit */
6259 * According to the manual, if the shift amount is greater
6260 * than 31 or less than 0 the the shift amount should be
6261 * mod 32. In reality the mips assembler issues an error.
6262 * We issue a warning and mask out all but the low 5 bits.
6264 my_getExpression (&imm_expr
, s
);
6265 check_absolute_expr (ip
, &imm_expr
);
6266 if ((unsigned long) imm_expr
.X_add_number
> 31)
6268 as_warn ("Improper shift amount (%ld)",
6269 (long) imm_expr
.X_add_number
);
6270 imm_expr
.X_add_number
= imm_expr
.X_add_number
& 0x1f;
6272 ip
->insn_opcode
|= imm_expr
.X_add_number
<< 6;
6273 imm_expr
.X_op
= O_absent
;
6277 case '>': /* shift amount minus 32 */
6278 my_getExpression (&imm_expr
, s
);
6279 check_absolute_expr (ip
, &imm_expr
);
6280 if ((unsigned long) imm_expr
.X_add_number
< 32
6281 || (unsigned long) imm_expr
.X_add_number
> 63)
6283 ip
->insn_opcode
|= (imm_expr
.X_add_number
- 32) << 6;
6284 imm_expr
.X_op
= O_absent
;
6288 case 'k': /* cache code */
6289 case 'h': /* prefx code */
6290 my_getExpression (&imm_expr
, s
);
6291 check_absolute_expr (ip
, &imm_expr
);
6292 if ((unsigned long) imm_expr
.X_add_number
> 31)
6294 as_warn ("Invalid value for `%s' (%lu)",
6296 (unsigned long) imm_expr
.X_add_number
);
6297 imm_expr
.X_add_number
&= 0x1f;
6300 ip
->insn_opcode
|= imm_expr
.X_add_number
<< OP_SH_CACHE
;
6302 ip
->insn_opcode
|= imm_expr
.X_add_number
<< OP_SH_PREFX
;
6303 imm_expr
.X_op
= O_absent
;
6307 case 'c': /* break code */
6308 my_getExpression (&imm_expr
, s
);
6309 check_absolute_expr (ip
, &imm_expr
);
6310 if ((unsigned) imm_expr
.X_add_number
> 1023)
6311 as_warn ("Illegal break code (%ld)",
6312 (long) imm_expr
.X_add_number
);
6313 ip
->insn_opcode
|= imm_expr
.X_add_number
<< 16;
6314 imm_expr
.X_op
= O_absent
;
6318 case 'B': /* syscall code */
6319 my_getExpression (&imm_expr
, s
);
6320 check_absolute_expr (ip
, &imm_expr
);
6321 if ((unsigned) imm_expr
.X_add_number
> 0xfffff)
6322 as_warn ("Illegal syscall code (%ld)",
6323 (long) imm_expr
.X_add_number
);
6324 ip
->insn_opcode
|= imm_expr
.X_add_number
<< 6;
6325 imm_expr
.X_op
= O_absent
;
6329 case 'C': /* Coprocessor code */
6330 my_getExpression (&imm_expr
, s
);
6331 check_absolute_expr (ip
, &imm_expr
);
6332 if ((unsigned long) imm_expr
.X_add_number
>= (1<<25))
6334 as_warn ("Coproccesor code > 25 bits (%ld)",
6335 (long) imm_expr
.X_add_number
);
6336 imm_expr
.X_add_number
&= ((1<<25) - 1);
6338 ip
->insn_opcode
|= imm_expr
.X_add_number
;
6339 imm_expr
.X_op
= O_absent
;
6343 case 'b': /* base register */
6344 case 'd': /* destination register */
6345 case 's': /* source register */
6346 case 't': /* target register */
6347 case 'r': /* both target and source */
6348 case 'v': /* both dest and source */
6349 case 'w': /* both dest and target */
6350 case 'E': /* coprocessor target register */
6351 case 'G': /* coprocessor destination register */
6352 case 'x': /* ignore register name */
6353 case 'z': /* must be zero register */
6367 while (isdigit (*s
));
6369 as_bad ("Invalid register number (%d)", regno
);
6371 else if (*args
== 'E' || *args
== 'G')
6375 if (s
[1] == 'f' && s
[2] == 'p')
6380 else if (s
[1] == 's' && s
[2] == 'p')
6385 else if (s
[1] == 'g' && s
[2] == 'p')
6390 else if (s
[1] == 'a' && s
[2] == 't')
6395 else if (s
[1] == 'k' && s
[2] == 't' && s
[3] == '0')
6400 else if (s
[1] == 'k' && s
[2] == 't' && s
[3] == '1')
6412 as_warn ("Used $at without \".set noat\"");
6418 if (c
== 'r' || c
== 'v' || c
== 'w')
6425 /* 'z' only matches $0. */
6426 if (c
== 'z' && regno
!= 0)
6434 ip
->insn_opcode
|= regno
<< 21;
6438 ip
->insn_opcode
|= regno
<< 11;
6443 ip
->insn_opcode
|= regno
<< 16;
6446 /* This case exists because on the r3000 trunc
6447 expands into a macro which requires a gp
6448 register. On the r6000 or r4000 it is
6449 assembled into a single instruction which
6450 ignores the register. Thus the insn version
6451 is MIPS_ISA2 and uses 'x', and the macro
6452 version is MIPS_ISA1 and uses 't'. */
6455 /* This case is for the div instruction, which
6456 acts differently if the destination argument
6457 is $0. This only matches $0, and is checked
6458 outside the switch. */
6469 ip
->insn_opcode
|= lastregno
<< 21;
6472 ip
->insn_opcode
|= lastregno
<< 16;
6477 case 'D': /* floating point destination register */
6478 case 'S': /* floating point source register */
6479 case 'T': /* floating point target register */
6480 case 'R': /* floating point source register */
6484 if (s
[0] == '$' && s
[1] == 'f' && isdigit (s
[2]))
6494 while (isdigit (*s
));
6497 as_bad ("Invalid float register number (%d)", regno
);
6499 if ((regno
& 1) != 0
6501 && ! (strcmp (str
, "mtc1") == 0
6502 || strcmp (str
, "mfc1") == 0
6503 || strcmp (str
, "lwc1") == 0
6504 || strcmp (str
, "swc1") == 0
6505 || strcmp (str
, "l.s") == 0
6506 || strcmp (str
, "s.s") == 0))
6507 as_warn ("Float register should be even, was %d",
6515 if (c
== 'V' || c
== 'W')
6525 ip
->insn_opcode
|= regno
<< 6;
6529 ip
->insn_opcode
|= regno
<< 11;
6533 ip
->insn_opcode
|= regno
<< 16;
6536 ip
->insn_opcode
|= regno
<< 21;
6545 ip
->insn_opcode
|= lastregno
<< 11;
6548 ip
->insn_opcode
|= lastregno
<< 16;
6554 my_getExpression (&imm_expr
, s
);
6555 if (imm_expr
.X_op
!= O_big
6556 && imm_expr
.X_op
!= O_constant
)
6557 insn_error
= "absolute expression required";
6562 my_getExpression (&offset_expr
, s
);
6563 imm_reloc
= BFD_RELOC_32
;
6575 unsigned char temp
[8];
6577 unsigned int length
;
6582 /* These only appear as the last operand in an
6583 instruction, and every instruction that accepts
6584 them in any variant accepts them in all variants.
6585 This means we don't have to worry about backing out
6586 any changes if the instruction does not match.
6588 The difference between them is the size of the
6589 floating point constant and where it goes. For 'F'
6590 and 'L' the constant is 64 bits; for 'f' and 'l' it
6591 is 32 bits. Where the constant is placed is based
6592 on how the MIPS assembler does things:
6595 f -- immediate value
6598 The .lit4 and .lit8 sections are only used if
6599 permitted by the -G argument.
6601 When generating embedded PIC code, we use the
6602 .lit8 section but not the .lit4 section (we can do
6603 .lit4 inline easily; we need to put .lit8
6604 somewhere in the data segment, and using .lit8
6605 permits the linker to eventually combine identical
6608 f64
= *args
== 'F' || *args
== 'L';
6610 save_in
= input_line_pointer
;
6611 input_line_pointer
= s
;
6612 err
= md_atof (f64
? 'd' : 'f', (char *) temp
, &len
);
6614 s
= input_line_pointer
;
6615 input_line_pointer
= save_in
;
6616 if (err
!= NULL
&& *err
!= '\0')
6618 as_bad ("Bad floating point constant: %s", err
);
6619 memset (temp
, '\0', sizeof temp
);
6620 length
= f64
? 8 : 4;
6623 assert (length
== (f64
? 8 : 4));
6627 && (! USE_GLOBAL_POINTER_OPT
6628 || mips_pic
== EMBEDDED_PIC
6629 || g_switch_value
< 4)
6632 imm_expr
.X_op
= O_constant
;
6633 if (! target_big_endian
)
6634 imm_expr
.X_add_number
=
6635 (((((((int) temp
[3] << 8)
6640 imm_expr
.X_add_number
=
6641 (((((((int) temp
[0] << 8)
6648 const char *newname
;
6651 /* Switch to the right section. */
6653 subseg
= now_subseg
;
6656 default: /* unused default case avoids warnings. */
6658 newname
= RDATA_SECTION_NAME
;
6659 if (USE_GLOBAL_POINTER_OPT
&& g_switch_value
>= 8)
6663 newname
= RDATA_SECTION_NAME
;
6666 assert (!USE_GLOBAL_POINTER_OPT
6667 || g_switch_value
>= 4);
6671 new_seg
= subseg_new (newname
, (subsegT
) 0);
6672 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
6673 bfd_set_section_flags (stdoutput
, new_seg
,
6678 frag_align (*args
== 'l' ? 2 : 3, 0);
6679 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
6680 record_alignment (new_seg
, 4);
6682 record_alignment (new_seg
, *args
== 'l' ? 2 : 3);
6684 as_bad ("Can't use floating point insn in this section");
6686 /* Set the argument to the current address in the
6688 offset_expr
.X_op
= O_symbol
;
6689 offset_expr
.X_add_symbol
=
6690 symbol_new ("L0\001", now_seg
,
6691 (valueT
) frag_now_fix (), frag_now
);
6692 offset_expr
.X_add_number
= 0;
6694 /* Put the floating point number into the section. */
6695 p
= frag_more ((int) length
);
6696 memcpy (p
, temp
, length
);
6698 /* Switch back to the original section. */
6699 subseg_set (seg
, subseg
);
6704 case 'i': /* 16 bit unsigned immediate */
6705 case 'j': /* 16 bit signed immediate */
6706 imm_reloc
= BFD_RELOC_LO16
;
6707 c
= my_getSmallExpression (&imm_expr
, s
);
6712 if (imm_expr
.X_op
== O_constant
)
6713 imm_expr
.X_add_number
=
6714 (imm_expr
.X_add_number
>> 16) & 0xffff;
6717 imm_reloc
= BFD_RELOC_HI16_S
;
6718 imm_unmatched_hi
= true;
6721 imm_reloc
= BFD_RELOC_HI16
;
6726 if ((c
== '\0' && imm_expr
.X_op
!= O_constant
)
6727 || ((imm_expr
.X_add_number
< 0
6728 || imm_expr
.X_add_number
>= 0x10000)
6729 && imm_expr
.X_op
== O_constant
))
6731 if (insn
+ 1 < &mips_opcodes
[NUMOPCODES
] &&
6732 !strcmp (insn
->name
, insn
[1].name
))
6734 if (imm_expr
.X_op
!= O_constant
6735 && imm_expr
.X_op
!= O_big
)
6736 insn_error
= "absolute expression required";
6738 as_bad ("16 bit expression not in range 0..65535");
6746 /* The upper bound should be 0x8000, but
6747 unfortunately the MIPS assembler accepts numbers
6748 from 0x8000 to 0xffff and sign extends them, and
6749 we want to be compatible. We only permit this
6750 extended range for an instruction which does not
6751 provide any further alternates, since those
6752 alternates may handle other cases. People should
6753 use the numbers they mean, rather than relying on
6754 a mysterious sign extension. */
6755 more
= (insn
+ 1 < &mips_opcodes
[NUMOPCODES
] &&
6756 strcmp (insn
->name
, insn
[1].name
) == 0);
6761 if ((c
== '\0' && imm_expr
.X_op
!= O_constant
)
6762 || ((imm_expr
.X_add_number
< -0x8000
6763 || imm_expr
.X_add_number
>= max
)
6764 && imm_expr
.X_op
== O_constant
)
6766 && imm_expr
.X_add_number
< 0
6768 && imm_expr
.X_unsigned
6769 && sizeof (imm_expr
.X_add_number
) <= 4))
6773 if (imm_expr
.X_op
!= O_constant
6774 && imm_expr
.X_op
!= O_big
)
6775 insn_error
= "absolute expression required";
6777 as_bad ("16 bit expression not in range -32768..32767");
6783 case 'o': /* 16 bit offset */
6784 c
= my_getSmallExpression (&offset_expr
, s
);
6786 /* If this value won't fit into a 16 bit offset, then go
6787 find a macro that will generate the 32 bit offset
6788 code pattern. As a special hack, we accept the
6789 difference of two local symbols as a constant. This
6790 is required to suppose embedded PIC switches, which
6791 use an instruction which looks like
6792 lw $4,$L12-$LS12($4)
6793 The problem with handling this in a more general
6794 fashion is that the macro function doesn't expect to
6795 see anything which can be handled in a single
6796 constant instruction. */
6798 && (offset_expr
.X_op
!= O_constant
6799 || offset_expr
.X_add_number
>= 0x8000
6800 || offset_expr
.X_add_number
< -0x8000)
6801 && (mips_pic
!= EMBEDDED_PIC
6802 || offset_expr
.X_op
!= O_subtract
6803 || now_seg
!= text_section
6804 || (S_GET_SEGMENT (offset_expr
.X_op_symbol
)
6808 offset_reloc
= BFD_RELOC_LO16
;
6809 if (c
== 'h' || c
== 'H')
6811 assert (offset_expr
.X_op
== O_constant
);
6812 offset_expr
.X_add_number
=
6813 (offset_expr
.X_add_number
>> 16) & 0xffff;
6818 case 'p': /* pc relative offset */
6819 offset_reloc
= BFD_RELOC_16_PCREL_S2
;
6820 my_getExpression (&offset_expr
, s
);
6824 case 'u': /* upper 16 bits */
6825 c
= my_getSmallExpression (&imm_expr
, s
);
6826 if (imm_expr
.X_op
== O_constant
6827 && (imm_expr
.X_add_number
< 0
6828 || imm_expr
.X_add_number
>= 0x10000))
6829 as_bad ("lui expression not in range 0..65535");
6830 imm_reloc
= BFD_RELOC_LO16
;
6835 if (imm_expr
.X_op
== O_constant
)
6836 imm_expr
.X_add_number
=
6837 (imm_expr
.X_add_number
>> 16) & 0xffff;
6840 imm_reloc
= BFD_RELOC_HI16_S
;
6841 imm_unmatched_hi
= true;
6844 imm_reloc
= BFD_RELOC_HI16
;
6850 case 'a': /* 26 bit address */
6851 my_getExpression (&offset_expr
, s
);
6853 offset_reloc
= BFD_RELOC_MIPS_JMP
;
6856 case 'N': /* 3 bit branch condition code */
6857 case 'M': /* 3 bit compare condition code */
6858 if (strncmp (s
, "$fcc", 4) != 0)
6868 while (isdigit (*s
));
6870 as_bad ("invalid condition code register $fcc%d", regno
);
6872 ip
->insn_opcode
|= regno
<< OP_SH_BCC
;
6874 ip
->insn_opcode
|= regno
<< OP_SH_CCC
;
6878 fprintf (stderr
, "bad char = '%c'\n", *args
);
6883 /* Args don't match. */
6884 if (insn
+ 1 < &mips_opcodes
[NUMOPCODES
] &&
6885 !strcmp (insn
->name
, insn
[1].name
))
6891 insn_error
= "illegal operands";
6896 /* This routine assembles an instruction into its binary format when
6897 assembling for the mips16. As a side effect, it sets one of the
6898 global variables imm_reloc or offset_reloc to the type of
6899 relocation to do if one of the operands is an address expression.
6900 It also sets mips16_small and mips16_ext if the user explicitly
6901 requested a small or extended instruction. */
6906 struct mips_cl_insn
*ip
;
6910 struct mips_opcode
*insn
;
6913 unsigned int lastregno
= 0;
6918 mips16_small
= false;
6921 for (s
= str
; islower (*s
); ++s
)
6933 if (s
[1] == 't' && s
[2] == ' ')
6936 mips16_small
= true;
6940 else if (s
[1] == 'e' && s
[2] == ' ')
6949 insn_error
= "unknown opcode";
6953 if (! mips16_autoextend
&& ! mips16_ext
)
6954 mips16_small
= true;
6956 if ((insn
= (struct mips_opcode
*) hash_find (mips16_op_hash
, str
)) == NULL
)
6958 insn_error
= "unrecognized opcode";
6965 assert (strcmp (insn
->name
, str
) == 0);
6968 ip
->insn_opcode
= insn
->match
;
6969 ip
->use_extend
= false;
6970 imm_expr
.X_op
= O_absent
;
6971 imm_reloc
= BFD_RELOC_UNUSED
;
6972 offset_expr
.X_op
= O_absent
;
6973 offset_reloc
= BFD_RELOC_UNUSED
;
6974 for (args
= insn
->args
; 1; ++args
)
6981 /* In this switch statement we call break if we did not find
6982 a match, continue if we did find a match, or return if we
6991 /* Stuff the immediate value in now, if we can. */
6992 if (imm_expr
.X_op
== O_constant
6993 && imm_reloc
> BFD_RELOC_UNUSED
6994 && insn
->pinfo
!= INSN_MACRO
)
6996 mips16_immed ((char *) NULL
, 0,
6997 imm_reloc
- BFD_RELOC_UNUSED
,
6998 imm_expr
.X_add_number
, true, mips16_small
,
6999 mips16_ext
, &ip
->insn_opcode
,
7000 &ip
->use_extend
, &ip
->extend
);
7001 imm_expr
.X_op
= O_absent
;
7002 imm_reloc
= BFD_RELOC_UNUSED
;
7016 ip
->insn_opcode
|= lastregno
<< MIPS16OP_SH_RX
;
7019 ip
->insn_opcode
|= lastregno
<< MIPS16OP_SH_RY
;
7035 ip
->insn_opcode
|= lastregno
<< MIPS16OP_SH_RX
;
7037 ip
->insn_opcode
|= lastregno
<< MIPS16OP_SH_RY
;
7064 while (isdigit (*s
));
7067 as_bad ("invalid register number (%d)", regno
);
7073 if (s
[1] == 'f' && s
[2] == 'p')
7078 else if (s
[1] == 's' && s
[2] == 'p')
7083 else if (s
[1] == 'g' && s
[2] == 'p')
7088 else if (s
[1] == 'a' && s
[2] == 't')
7093 else if (s
[1] == 'k' && s
[2] == 't' && s
[3] == '0')
7098 else if (s
[1] == 'k' && s
[2] == 't' && s
[3] == '1')
7111 if (c
== 'v' || c
== 'w')
7113 regno
= mips16_to_32_reg_map
[lastregno
];
7127 regno
= mips32_to_16_reg_map
[regno
];
7132 regno
= ILLEGAL_REG
;
7137 regno
= ILLEGAL_REG
;
7142 regno
= ILLEGAL_REG
;
7147 if (regno
== AT
&& ! mips_noat
)
7148 as_warn ("used $at without \".set noat\"");
7155 if (regno
== ILLEGAL_REG
)
7162 ip
->insn_opcode
|= regno
<< MIPS16OP_SH_RX
;
7166 ip
->insn_opcode
|= regno
<< MIPS16OP_SH_RY
;
7169 ip
->insn_opcode
|= regno
<< MIPS16OP_SH_RZ
;
7172 ip
->insn_opcode
|= regno
<< MIPS16OP_SH_MOVE32Z
;
7178 ip
->insn_opcode
|= regno
<< MIPS16OP_SH_REGR32
;
7181 regno
= ((regno
& 7) << 2) | ((regno
& 0x18) >> 3);
7182 ip
->insn_opcode
|= regno
<< MIPS16OP_SH_REG32R
;
7192 if (strncmp (s
, "$pc", 3) == 0)
7216 && strncmp (s
+ 1, "gprel(", sizeof "gprel(" - 1) == 0)
7218 /* This is %gprel(SYMBOL). We need to read SYMBOL,
7219 and generate the appropriate reloc. If the text
7220 inside %gprel is not a symbol name with an
7221 optional offset, then we generate a normal reloc
7222 and will probably fail later. */
7223 my_getExpression (&imm_expr
, s
+ sizeof "%gprel" - 1);
7224 if (imm_expr
.X_op
== O_symbol
)
7227 imm_reloc
= BFD_RELOC_MIPS16_GPREL
;
7229 ip
->use_extend
= true;
7236 /* Just pick up a normal expression. */
7237 my_getExpression (&imm_expr
, s
);
7240 if (imm_expr
.X_op
== O_register
)
7242 /* What we thought was an expression turned out to
7245 if (s
[0] == '(' && args
[1] == '(')
7247 /* It looks like the expression was omitted
7248 before a register indirection, which means
7249 that the expression is implicitly zero. We
7250 still set up imm_expr, so that we handle
7251 explicit extensions correctly. */
7252 imm_expr
.X_op
= O_constant
;
7253 imm_expr
.X_add_number
= 0;
7254 imm_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
7261 /* We need to relax this instruction. */
7262 imm_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
7271 /* We use offset_reloc rather than imm_reloc for the PC
7272 relative operands. This lets macros with both
7273 immediate and address operands work correctly. */
7274 my_getExpression (&offset_expr
, s
);
7276 if (offset_expr
.X_op
== O_register
)
7279 /* We need to relax this instruction. */
7280 offset_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
7284 case '6': /* break code */
7285 my_getExpression (&imm_expr
, s
);
7286 check_absolute_expr (ip
, &imm_expr
);
7287 if ((unsigned long) imm_expr
.X_add_number
> 63)
7289 as_warn ("Invalid value for `%s' (%lu)",
7291 (unsigned long) imm_expr
.X_add_number
);
7292 imm_expr
.X_add_number
&= 0x3f;
7294 ip
->insn_opcode
|= imm_expr
.X_add_number
<< MIPS16OP_SH_IMM6
;
7295 imm_expr
.X_op
= O_absent
;
7299 case 'a': /* 26 bit address */
7300 my_getExpression (&offset_expr
, s
);
7302 offset_reloc
= BFD_RELOC_MIPS16_JMP
;
7303 ip
->insn_opcode
<<= 16;
7306 case 'l': /* register list for entry macro */
7307 case 'L': /* register list for exit macro */
7317 int freg
, reg1
, reg2
;
7319 while (*s
== ' ' || *s
== ',')
7323 as_bad ("can't parse register list");
7335 while (isdigit (*s
))
7357 as_bad ("invalid register list");
7362 while (isdigit (*s
))
7369 if (freg
&& reg1
== 0 && reg2
== 0 && c
== 'L')
7374 else if (freg
&& reg1
== 0 && reg2
== 1 && c
== 'L')
7379 else if (reg1
== 4 && reg2
>= 4 && reg2
<= 7 && c
!= 'L')
7380 mask
|= (reg2
- 3) << 3;
7381 else if (reg1
== 16 && reg2
>= 16 && reg2
<= 17)
7382 mask
|= (reg2
- 15) << 1;
7383 else if (reg1
== 31 && reg2
== 31)
7387 as_bad ("invalid register list");
7391 /* The mask is filled in in the opcode table for the
7392 benefit of the disassembler. We remove it before
7393 applying the actual mask. */
7394 ip
->insn_opcode
&= ~ ((7 << 3) << MIPS16OP_SH_IMM6
);
7395 ip
->insn_opcode
|= mask
<< MIPS16OP_SH_IMM6
;
7405 /* Args don't match. */
7406 if (insn
+ 1 < &mips16_opcodes
[bfd_mips16_num_opcodes
] &&
7407 strcmp (insn
->name
, insn
[1].name
) == 0)
7414 insn_error
= "illegal operands";
7420 /* This structure holds information we know about a mips16 immediate
7423 struct mips16_immed_operand
7425 /* The type code used in the argument string in the opcode table. */
7427 /* The number of bits in the short form of the opcode. */
7429 /* The number of bits in the extended form of the opcode. */
7431 /* The amount by which the short form is shifted when it is used;
7432 for example, the sw instruction has a shift count of 2. */
7434 /* The amount by which the short form is shifted when it is stored
7435 into the instruction code. */
7437 /* Non-zero if the short form is unsigned. */
7439 /* Non-zero if the extended form is unsigned. */
7441 /* Non-zero if the value is PC relative. */
7445 /* The mips16 immediate operand types. */
7447 static const struct mips16_immed_operand mips16_immed_operands
[] =
7449 { '<', 3, 5, 0, MIPS16OP_SH_RZ
, 1, 1, 0 },
7450 { '>', 3, 5, 0, MIPS16OP_SH_RX
, 1, 1, 0 },
7451 { '[', 3, 6, 0, MIPS16OP_SH_RZ
, 1, 1, 0 },
7452 { ']', 3, 6, 0, MIPS16OP_SH_RX
, 1, 1, 0 },
7453 { '4', 4, 15, 0, MIPS16OP_SH_IMM4
, 0, 0, 0 },
7454 { '5', 5, 16, 0, MIPS16OP_SH_IMM5
, 1, 0, 0 },
7455 { 'H', 5, 16, 1, MIPS16OP_SH_IMM5
, 1, 0, 0 },
7456 { 'W', 5, 16, 2, MIPS16OP_SH_IMM5
, 1, 0, 0 },
7457 { 'D', 5, 16, 3, MIPS16OP_SH_IMM5
, 1, 0, 0 },
7458 { 'j', 5, 16, 0, MIPS16OP_SH_IMM5
, 0, 0, 0 },
7459 { '8', 8, 16, 0, MIPS16OP_SH_IMM8
, 1, 0, 0 },
7460 { 'V', 8, 16, 2, MIPS16OP_SH_IMM8
, 1, 0, 0 },
7461 { 'C', 8, 16, 3, MIPS16OP_SH_IMM8
, 1, 0, 0 },
7462 { 'U', 8, 16, 0, MIPS16OP_SH_IMM8
, 1, 1, 0 },
7463 { 'k', 8, 16, 0, MIPS16OP_SH_IMM8
, 0, 0, 0 },
7464 { 'K', 8, 16, 3, MIPS16OP_SH_IMM8
, 0, 0, 0 },
7465 { 'p', 8, 16, 0, MIPS16OP_SH_IMM8
, 0, 0, 1 },
7466 { 'q', 11, 16, 0, MIPS16OP_SH_IMM8
, 0, 0, 1 },
7467 { 'A', 8, 16, 2, MIPS16OP_SH_IMM8
, 1, 0, 1 },
7468 { 'B', 5, 16, 3, MIPS16OP_SH_IMM5
, 1, 0, 1 },
7469 { 'E', 5, 16, 2, MIPS16OP_SH_IMM5
, 1, 0, 1 }
7472 #define MIPS16_NUM_IMMED \
7473 (sizeof mips16_immed_operands / sizeof mips16_immed_operands[0])
7475 /* Handle a mips16 instruction with an immediate value. This or's the
7476 small immediate value into *INSN. It sets *USE_EXTEND to indicate
7477 whether an extended value is needed; if one is needed, it sets
7478 *EXTEND to the value. The argument type is TYPE. The value is VAL.
7479 If SMALL is true, an unextended opcode was explicitly requested.
7480 If EXT is true, an extended opcode was explicitly requested. If
7481 WARN is true, warn if EXT does not match reality. */
7484 mips16_immed (file
, line
, type
, val
, warn
, small
, ext
, insn
, use_extend
,
7493 unsigned long *insn
;
7494 boolean
*use_extend
;
7495 unsigned short *extend
;
7497 register const struct mips16_immed_operand
*op
;
7498 int mintiny
, maxtiny
;
7501 op
= mips16_immed_operands
;
7502 while (op
->type
!= type
)
7505 assert (op
< mips16_immed_operands
+ MIPS16_NUM_IMMED
);
7510 if (type
== '<' || type
== '>' || type
== '[' || type
== ']')
7513 maxtiny
= 1 << op
->nbits
;
7518 maxtiny
= (1 << op
->nbits
) - 1;
7523 mintiny
= - (1 << (op
->nbits
- 1));
7524 maxtiny
= (1 << (op
->nbits
- 1)) - 1;
7527 /* Branch offsets have an implicit 0 in the lowest bit. */
7528 if (type
== 'p' || type
== 'q')
7531 if ((val
& ((1 << op
->shift
) - 1)) != 0
7532 || val
< (mintiny
<< op
->shift
)
7533 || val
> (maxtiny
<< op
->shift
))
7538 if (warn
&& ext
&& ! needext
)
7539 as_warn_where (file
, line
, "extended operand requested but not required");
7540 if (small
&& needext
)
7541 as_bad_where (file
, line
, "invalid unextended operand value");
7543 if (small
|| (! ext
&& ! needext
))
7547 *use_extend
= false;
7548 insnval
= ((val
>> op
->shift
) & ((1 << op
->nbits
) - 1));
7549 insnval
<<= op
->op_shift
;
7554 long minext
, maxext
;
7560 maxext
= (1 << op
->extbits
) - 1;
7564 minext
= - (1 << (op
->extbits
- 1));
7565 maxext
= (1 << (op
->extbits
- 1)) - 1;
7567 if (val
< minext
|| val
> maxext
)
7568 as_bad_where (file
, line
,
7569 "operand value out of range for instruction");
7572 if (op
->extbits
== 16)
7574 extval
= ((val
>> 11) & 0x1f) | (val
& 0x7e0);
7577 else if (op
->extbits
== 15)
7579 extval
= ((val
>> 11) & 0xf) | (val
& 0x7f0);
7584 extval
= ((val
& 0x1f) << 6) | (val
& 0x20);
7588 *extend
= (unsigned short) extval
;
7597 my_getSmallExpression (ep
, str
)
7608 ((str
[1] == 'h' && str
[2] == 'i')
7609 || (str
[1] == 'H' && str
[2] == 'I')
7610 || (str
[1] == 'l' && str
[2] == 'o'))
7622 * A small expression may be followed by a base register.
7623 * Scan to the end of this operand, and then back over a possible
7624 * base register. Then scan the small expression up to that
7625 * point. (Based on code in sparc.c...)
7627 for (sp
= str
; *sp
&& *sp
!= ','; sp
++)
7629 if (sp
- 4 >= str
&& sp
[-1] == RP
)
7631 if (isdigit (sp
[-2]))
7633 for (sp
-= 3; sp
>= str
&& isdigit (*sp
); sp
--)
7635 if (*sp
== '$' && sp
> str
&& sp
[-1] == LP
)
7641 else if (sp
- 5 >= str
7644 && ((sp
[-3] == 'f' && sp
[-2] == 'p')
7645 || (sp
[-3] == 's' && sp
[-2] == 'p')
7646 || (sp
[-3] == 'g' && sp
[-2] == 'p')
7647 || (sp
[-3] == 'a' && sp
[-2] == 't')))
7653 /* no expression means zero offset */
7656 /* %xx(reg) is an error */
7657 ep
->X_op
= O_absent
;
7662 ep
->X_op
= O_constant
;
7665 ep
->X_add_symbol
= NULL
;
7666 ep
->X_op_symbol
= NULL
;
7667 ep
->X_add_number
= 0;
7672 my_getExpression (ep
, str
);
7679 my_getExpression (ep
, str
);
7680 return c
; /* => %hi or %lo encountered */
7684 my_getExpression (ep
, str
)
7690 save_in
= input_line_pointer
;
7691 input_line_pointer
= str
;
7693 expr_end
= input_line_pointer
;
7694 input_line_pointer
= save_in
;
7696 /* If we are in mips16 mode, and this is an expression based on `.',
7697 then we bump the value of the symbol by 1 since that is how other
7698 text symbols are handled. We don't bother to handle complex
7699 expressions, just `.' plus or minus a constant. */
7701 && ep
->X_op
== O_symbol
7702 && strcmp (S_GET_NAME (ep
->X_add_symbol
), FAKE_LABEL_NAME
) == 0
7703 && S_GET_SEGMENT (ep
->X_add_symbol
) == now_seg
7704 && ep
->X_add_symbol
->sy_frag
== frag_now
7705 && ep
->X_add_symbol
->sy_value
.X_op
== O_constant
7706 && ep
->X_add_symbol
->sy_value
.X_add_number
== frag_now_fix ())
7707 ++ep
->X_add_symbol
->sy_value
.X_add_number
;
7710 /* Turn a string in input_line_pointer into a floating point constant
7711 of type type, and store the appropriate bytes in *litP. The number
7712 of LITTLENUMS emitted is stored in *sizeP . An error message is
7713 returned, or NULL on OK. */
7716 md_atof (type
, litP
, sizeP
)
7722 LITTLENUM_TYPE words
[4];
7738 return "bad call to md_atof";
7741 t
= atof_ieee (input_line_pointer
, type
, words
);
7743 input_line_pointer
= t
;
7747 if (! target_big_endian
)
7749 for (i
= prec
- 1; i
>= 0; i
--)
7751 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
7757 for (i
= 0; i
< prec
; i
++)
7759 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
7768 md_number_to_chars (buf
, val
, n
)
7773 if (target_big_endian
)
7774 number_to_chars_bigendian (buf
, val
, n
);
7776 number_to_chars_littleendian (buf
, val
, n
);
7779 CONST
char *md_shortopts
= "O::g::G:";
7781 struct option md_longopts
[] = {
7782 #define OPTION_MIPS1 (OPTION_MD_BASE + 1)
7783 {"mips0", no_argument
, NULL
, OPTION_MIPS1
},
7784 {"mips1", no_argument
, NULL
, OPTION_MIPS1
},
7785 #define OPTION_MIPS2 (OPTION_MD_BASE + 2)
7786 {"mips2", no_argument
, NULL
, OPTION_MIPS2
},
7787 #define OPTION_MIPS3 (OPTION_MD_BASE + 3)
7788 {"mips3", no_argument
, NULL
, OPTION_MIPS3
},
7789 #define OPTION_MIPS4 (OPTION_MD_BASE + 4)
7790 {"mips4", no_argument
, NULL
, OPTION_MIPS4
},
7791 #define OPTION_MCPU (OPTION_MD_BASE + 5)
7792 {"mcpu", required_argument
, NULL
, OPTION_MCPU
},
7793 #define OPTION_MEMBEDDED_PIC (OPTION_MD_BASE + 6)
7794 {"membedded-pic", no_argument
, NULL
, OPTION_MEMBEDDED_PIC
},
7795 #define OPTION_TRAP (OPTION_MD_BASE + 9)
7796 {"trap", no_argument
, NULL
, OPTION_TRAP
},
7797 {"no-break", no_argument
, NULL
, OPTION_TRAP
},
7798 #define OPTION_BREAK (OPTION_MD_BASE + 10)
7799 {"break", no_argument
, NULL
, OPTION_BREAK
},
7800 {"no-trap", no_argument
, NULL
, OPTION_BREAK
},
7801 #define OPTION_EB (OPTION_MD_BASE + 11)
7802 {"EB", no_argument
, NULL
, OPTION_EB
},
7803 #define OPTION_EL (OPTION_MD_BASE + 12)
7804 {"EL", no_argument
, NULL
, OPTION_EL
},
7805 #define OPTION_M4650 (OPTION_MD_BASE + 13)
7806 {"m4650", no_argument
, NULL
, OPTION_M4650
},
7807 #define OPTION_NO_M4650 (OPTION_MD_BASE + 14)
7808 {"no-m4650", no_argument
, NULL
, OPTION_NO_M4650
},
7809 #define OPTION_M4010 (OPTION_MD_BASE + 15)
7810 {"m4010", no_argument
, NULL
, OPTION_M4010
},
7811 #define OPTION_NO_M4010 (OPTION_MD_BASE + 16)
7812 {"no-m4010", no_argument
, NULL
, OPTION_NO_M4010
},
7813 #define OPTION_M4100 (OPTION_MD_BASE + 17)
7814 {"m4100", no_argument
, NULL
, OPTION_M4100
},
7815 #define OPTION_NO_M4100 (OPTION_MD_BASE + 18)
7816 {"no-m4100", no_argument
, NULL
, OPTION_NO_M4100
},
7817 #define OPTION_MIPS16 (OPTION_MD_BASE + 22)
7818 {"mips16", no_argument
, NULL
, OPTION_MIPS16
},
7819 #define OPTION_NO_MIPS16 (OPTION_MD_BASE + 23)
7820 {"no-mips16", no_argument
, NULL
, OPTION_NO_MIPS16
},
7821 /* start-sanitize-5900 */
7822 #define OPTION_M5900 (OPTION_MD_BASE + 24)
7823 {"m5900", no_argument
, NULL
, OPTION_M5900
},
7824 #define OPTION_NO_M5900 (OPTION_MD_BASE + 25)
7825 {"no-m5900", no_argument
, NULL
, OPTION_NO_M5900
},
7826 /* end-sanitize-5900 */
7828 #define OPTION_CALL_SHARED (OPTION_MD_BASE + 7)
7829 #define OPTION_NON_SHARED (OPTION_MD_BASE + 8)
7830 #define OPTION_XGOT (OPTION_MD_BASE + 19)
7831 #define OPTION_32 (OPTION_MD_BASE + 20)
7832 #define OPTION_64 (OPTION_MD_BASE + 21)
7834 {"KPIC", no_argument
, NULL
, OPTION_CALL_SHARED
},
7835 {"xgot", no_argument
, NULL
, OPTION_XGOT
},
7836 {"call_shared", no_argument
, NULL
, OPTION_CALL_SHARED
},
7837 {"non_shared", no_argument
, NULL
, OPTION_NON_SHARED
},
7838 {"32", no_argument
, NULL
, OPTION_32
},
7839 {"64", no_argument
, NULL
, OPTION_64
},
7842 {NULL
, no_argument
, NULL
, 0}
7844 size_t md_longopts_size
= sizeof(md_longopts
);
7847 md_parse_option (c
, arg
)
7862 target_big_endian
= 1;
7866 target_big_endian
= 0;
7870 if (arg
&& arg
[1] == '0')
7880 mips_debug
= atoi (arg
);
7881 /* When the MIPS assembler sees -g or -g2, it does not do
7882 optimizations which limit full symbolic debugging. We take
7883 that to be equivalent to -O0. */
7884 if (mips_debug
== 2)
7916 /* Identify the processor type */
7918 if (strcmp (p
, "default") == 0
7919 || strcmp (p
, "DEFAULT") == 0)
7925 /* We need to cope with the various "vr" prefixes for the 4300
7927 if (*p
== 'v' || *p
== 'V')
7933 if (*p
== 'r' || *p
== 'R')
7940 if (strcmp (p
, "10000") == 0
7941 || strcmp (p
, "10k") == 0
7942 || strcmp (p
, "10K") == 0)
7947 if (strcmp (p
, "2000") == 0
7948 || strcmp (p
, "2k") == 0
7949 || strcmp (p
, "2K") == 0)
7954 if (strcmp (p
, "3000") == 0
7955 || strcmp (p
, "3k") == 0
7956 || strcmp (p
, "3K") == 0)
7961 if (strcmp (p
, "4000") == 0
7962 || strcmp (p
, "4k") == 0
7963 || strcmp (p
, "4K") == 0)
7965 else if (strcmp (p
, "4100") == 0)
7971 else if (strcmp (p
, "4300") == 0)
7973 else if (strcmp (p
, "4400") == 0)
7975 else if (strcmp (p
, "4600") == 0)
7977 else if (strcmp (p
, "4650") == 0)
7983 else if (strcmp (p
, "4010") == 0)
7992 if (strcmp (p
, "5000") == 0
7993 || strcmp (p
, "5k") == 0
7994 || strcmp (p
, "5K") == 0)
7996 /* start-sanitize-r5900 */
7997 else if (strcmp (p
, "5900") == 0)
7999 /* end-sanitize-r5900 */
8003 if (strcmp (p
, "6000") == 0
8004 || strcmp (p
, "6k") == 0
8005 || strcmp (p
, "6K") == 0)
8010 if (strcmp (p
, "8000") == 0
8011 || strcmp (p
, "8k") == 0
8012 || strcmp (p
, "8K") == 0)
8017 if (strcmp (p
, "orion") == 0)
8022 if (sv
&& mips_cpu
!= 4300 && mips_cpu
!= 4100 && mips_cpu
!= 5000)
8024 as_bad ("ignoring invalid leading 'v' in -mcpu=%s switch", arg
);
8030 as_bad ("invalid architecture -mcpu=%s", arg
);
8041 case OPTION_NO_M4650
:
8049 case OPTION_NO_M4010
:
8057 case OPTION_NO_M4100
:
8061 /* start-sanitize-r5900 */
8066 case OPTION_NO_M5900
:
8069 /* end-sanitize-r5900 */
8073 mips_no_prev_insn ();
8076 case OPTION_NO_MIPS16
:
8078 mips_no_prev_insn ();
8081 case OPTION_MEMBEDDED_PIC
:
8082 mips_pic
= EMBEDDED_PIC
;
8083 if (USE_GLOBAL_POINTER_OPT
&& g_switch_seen
)
8085 as_bad ("-G may not be used with embedded PIC code");
8088 g_switch_value
= 0x7fffffff;
8091 /* When generating ELF code, we permit -KPIC and -call_shared to
8092 select SVR4_PIC, and -non_shared to select no PIC. This is
8093 intended to be compatible with Irix 5. */
8094 case OPTION_CALL_SHARED
:
8095 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
8097 as_bad ("-call_shared is supported only for ELF format");
8100 mips_pic
= SVR4_PIC
;
8101 if (g_switch_seen
&& g_switch_value
!= 0)
8103 as_bad ("-G may not be used with SVR4 PIC code");
8109 case OPTION_NON_SHARED
:
8110 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
8112 as_bad ("-non_shared is supported only for ELF format");
8118 /* The -xgot option tells the assembler to use 32 offsets when
8119 accessing the got in SVR4_PIC mode. It is for Irix
8126 if (! USE_GLOBAL_POINTER_OPT
)
8128 as_bad ("-G is not supported for this configuration");
8131 else if (mips_pic
== SVR4_PIC
|| mips_pic
== EMBEDDED_PIC
)
8133 as_bad ("-G may not be used with SVR4 or embedded PIC code");
8137 g_switch_value
= atoi (arg
);
8141 /* The -32 and -64 options tell the assembler to output the 32
8142 bit or the 64 bit MIPS ELF format. */
8149 const char **list
, **l
;
8151 list
= bfd_target_list ();
8152 for (l
= list
; *l
!= NULL
; l
++)
8153 if (strcmp (*l
, "elf64-bigmips") == 0
8154 || strcmp (*l
, "elf64-littlemips") == 0)
8157 as_fatal ("No compiled in support for 64 bit object file format");
8171 md_show_usage (stream
)
8176 -membedded-pic generate embedded position independent code\n\
8177 -EB generate big endian output\n\
8178 -EL generate little endian output\n\
8179 -g, -g2 do not remove uneeded NOPs or swap branches\n\
8180 -G NUM allow referencing objects up to NUM bytes\n\
8181 implicitly with the gp register [default 8]\n");
8183 -mips1, -mcpu=r{2,3}000 generate code for r2000 and r3000\n\
8184 -mips2, -mcpu=r6000 generate code for r6000\n\
8185 -mips3, -mcpu=r4000 generate code for r4000\n\
8186 -mips4, -mcpu=r8000 generate code for r8000\n\
8187 -mcpu=vr4300 generate code for vr4300\n\
8188 -mcpu=vr4100 generate code for vr4100\n\
8189 -m4650 permit R4650 instructions\n\
8190 -no-m4650 do not permit R4650 instructions\n\
8191 -m4010 permit R4010 instructions\n\
8192 -no-m4010 do not permit R4010 instructions\n\
8193 -m4100 permit VR4100 instructions\n\
8194 -no-m4100 do not permit VR4100 instructions\n");
8196 -mips16 generate mips16 instructions\n\
8197 -no-mips16 do not generate mips16 instructions\n");
8199 -O0 remove unneeded NOPs, do not swap branches\n\
8200 -O remove unneeded NOPs and swap branches\n\
8201 --trap, --no-break trap exception on div by 0 and mult overflow\n\
8202 --break, --no-trap break exception on div by 0 and mult overflow\n");
8205 -KPIC, -call_shared generate SVR4 position independent code\n\
8206 -non_shared do not generate position independent code\n\
8207 -xgot assume a 32 bit GOT\n\
8208 -32 create 32 bit object file (default)\n\
8209 -64 create 64 bit object file\n");
8214 md_pcrel_from (fixP
)
8217 if (OUTPUT_FLAVOR
!= bfd_target_aout_flavour
8218 && fixP
->fx_addsy
!= (symbolS
*) NULL
8219 && ! S_IS_DEFINED (fixP
->fx_addsy
))
8221 /* This makes a branch to an undefined symbol be a branch to the
8222 current location. */
8226 /* return the address of the delay slot */
8227 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
8230 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
8231 reloc for a cons. We could use the definition there, except that
8232 we want to handle 64 bit relocs specially. */
8235 cons_fix_new_mips (frag
, where
, nbytes
, exp
)
8238 unsigned int nbytes
;
8242 /* If we are assembling in 32 bit mode, turn an 8 byte reloc into a
8244 if (nbytes
== 8 && ! mips_64
)
8246 if (target_big_endian
)
8252 if (nbytes
!= 2 && nbytes
!= 4 && nbytes
!= 8)
8253 as_bad ("Unsupported reloc size %d", nbytes
);
8255 fix_new_exp (frag_now
, where
, (int) nbytes
, exp
, 0,
8258 : (nbytes
== 4 ? BFD_RELOC_32
: BFD_RELOC_64
)));
8261 /* Sort any unmatched HI16_S relocs so that they immediately precede
8262 the corresponding LO reloc. This is called before md_apply_fix and
8263 tc_gen_reloc. Unmatched HI16_S relocs can only be generated by
8264 explicit use of the %hi modifier. */
8269 struct mips_hi_fixup
*l
;
8271 for (l
= mips_hi_fixup_list
; l
!= NULL
; l
= l
->next
)
8273 segment_info_type
*seginfo
;
8276 assert (l
->fixp
->fx_r_type
== BFD_RELOC_HI16_S
);
8278 /* Check quickly whether the next fixup happens to be a matching
8280 if (l
->fixp
->fx_next
!= NULL
8281 && l
->fixp
->fx_next
->fx_r_type
== BFD_RELOC_LO16
8282 && l
->fixp
->fx_addsy
== l
->fixp
->fx_next
->fx_addsy
8283 && l
->fixp
->fx_offset
== l
->fixp
->fx_next
->fx_offset
)
8286 /* Look through the fixups for this segment for a matching %lo.
8287 When we find one, move the %hi just in front of it. We do
8288 this in two passes. In the first pass, we try to find a
8289 unique %lo. In the second pass, we permit multiple %hi
8290 relocs for a single %lo (this is a GNU extension). */
8291 seginfo
= seg_info (l
->seg
);
8292 for (pass
= 0; pass
< 2; pass
++)
8297 for (f
= seginfo
->fix_root
; f
!= NULL
; f
= f
->fx_next
)
8299 /* Check whether this is a %lo fixup which matches l->fixp. */
8300 if (f
->fx_r_type
== BFD_RELOC_LO16
8301 && f
->fx_addsy
== l
->fixp
->fx_addsy
8302 && f
->fx_offset
== l
->fixp
->fx_offset
8305 || prev
->fx_r_type
!= BFD_RELOC_HI16_S
8306 || prev
->fx_addsy
!= f
->fx_addsy
8307 || prev
->fx_offset
!= f
->fx_offset
))
8311 /* Move l->fixp before f. */
8312 for (pf
= &seginfo
->fix_root
;
8314 pf
= &(*pf
)->fx_next
)
8315 assert (*pf
!= NULL
);
8317 *pf
= l
->fixp
->fx_next
;
8319 l
->fixp
->fx_next
= f
;
8321 seginfo
->fix_root
= l
->fixp
;
8323 prev
->fx_next
= l
->fixp
;
8335 as_warn_where (l
->fixp
->fx_file
, l
->fixp
->fx_line
,
8336 "Unmatched %%hi reloc");
8341 /* When generating embedded PIC code we need to use a special
8342 relocation to represent the difference of two symbols in the .text
8343 section (switch tables use a difference of this sort). See
8344 include/coff/mips.h for details. This macro checks whether this
8345 fixup requires the special reloc. */
8346 #define SWITCH_TABLE(fixp) \
8347 ((fixp)->fx_r_type == BFD_RELOC_32 \
8348 && (fixp)->fx_addsy != NULL \
8349 && (fixp)->fx_subsy != NULL \
8350 && S_GET_SEGMENT ((fixp)->fx_addsy) == text_section \
8351 && S_GET_SEGMENT ((fixp)->fx_subsy) == text_section)
8353 /* When generating embedded PIC code we must keep all PC relative
8354 relocations, in case the linker has to relax a call. We also need
8355 to keep relocations for switch table entries. */
8359 mips_force_relocation (fixp
)
8362 return (mips_pic
== EMBEDDED_PIC
8364 || SWITCH_TABLE (fixp
)
8365 || fixp
->fx_r_type
== BFD_RELOC_PCREL_HI16_S
8366 || fixp
->fx_r_type
== BFD_RELOC_PCREL_LO16
));
8369 /* Apply a fixup to the object file. */
8372 md_apply_fix (fixP
, valueP
)
8379 assert (fixP
->fx_size
== 4
8380 || fixP
->fx_r_type
== BFD_RELOC_16
8381 || fixP
->fx_r_type
== BFD_RELOC_64
);
8385 /* If we aren't adjusting this fixup to be against the section
8386 symbol, we need to adjust the value. */
8388 if (fixP
->fx_addsy
!= NULL
8389 && OUTPUT_FLAVOR
== bfd_target_elf_flavour
8390 && S_GET_OTHER (fixP
->fx_addsy
) == STO_MIPS16
)
8392 value
-= S_GET_VALUE (fixP
->fx_addsy
);
8393 if (value
!= 0 && ! fixP
->fx_pcrel
)
8395 /* In this case, the bfd_install_relocation routine will
8396 incorrectly add the symbol value back in. We just want
8397 the addend to appear in the object file. */
8398 value
-= S_GET_VALUE (fixP
->fx_addsy
);
8403 fixP
->fx_addnumber
= value
; /* Remember value for tc_gen_reloc */
8405 if (fixP
->fx_addsy
== NULL
&& ! fixP
->fx_pcrel
)
8408 switch (fixP
->fx_r_type
)
8410 case BFD_RELOC_MIPS_JMP
:
8411 case BFD_RELOC_HI16
:
8412 case BFD_RELOC_HI16_S
:
8413 case BFD_RELOC_MIPS_GPREL
:
8414 case BFD_RELOC_MIPS_LITERAL
:
8415 case BFD_RELOC_MIPS_CALL16
:
8416 case BFD_RELOC_MIPS_GOT16
:
8417 case BFD_RELOC_MIPS_GPREL32
:
8418 case BFD_RELOC_MIPS_GOT_HI16
:
8419 case BFD_RELOC_MIPS_GOT_LO16
:
8420 case BFD_RELOC_MIPS_CALL_HI16
:
8421 case BFD_RELOC_MIPS_CALL_LO16
:
8422 case BFD_RELOC_MIPS16_GPREL
:
8424 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
8425 "Invalid PC relative reloc");
8426 /* Nothing needed to do. The value comes from the reloc entry */
8429 case BFD_RELOC_MIPS16_JMP
:
8430 /* We currently always generate a reloc against a symbol, which
8431 means that we don't want an addend even if the symbol is
8433 fixP
->fx_addnumber
= 0;
8436 case BFD_RELOC_PCREL_HI16_S
:
8437 /* The addend for this is tricky if it is internal, so we just
8438 do everything here rather than in bfd_perform_relocation. */
8439 if ((fixP
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
8441 /* For an external symbol adjust by the address to make it
8442 pcrel_offset. We use the address of the RELLO reloc
8443 which follows this one. */
8444 value
+= (fixP
->fx_next
->fx_frag
->fr_address
8445 + fixP
->fx_next
->fx_where
);
8450 buf
= (unsigned char *) fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
8451 if (target_big_endian
)
8453 md_number_to_chars (buf
, value
, 2);
8456 case BFD_RELOC_PCREL_LO16
:
8457 /* The addend for this is tricky if it is internal, so we just
8458 do everything here rather than in bfd_perform_relocation. */
8459 if ((fixP
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
8460 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
8461 buf
= (unsigned char *) fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
8462 if (target_big_endian
)
8464 md_number_to_chars (buf
, value
, 2);
8468 /* This is handled like BFD_RELOC_32, but we output a sign
8469 extended value if we are only 32 bits. */
8471 || (mips_pic
== EMBEDDED_PIC
&& SWITCH_TABLE (fixP
)))
8473 if (8 <= sizeof (valueT
))
8474 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
8481 w1
= w2
= fixP
->fx_where
;
8482 if (target_big_endian
)
8486 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ w1
, value
, 4);
8487 if ((value
& 0x80000000) != 0)
8491 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ w2
, hiv
, 4);
8497 /* If we are deleting this reloc entry, we must fill in the
8498 value now. This can happen if we have a .word which is not
8499 resolved when it appears but is later defined. We also need
8500 to fill in the value if this is an embedded PIC switch table
8503 || (mips_pic
== EMBEDDED_PIC
&& SWITCH_TABLE (fixP
)))
8504 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
8509 /* If we are deleting this reloc entry, we must fill in the
8511 assert (fixP
->fx_size
== 2);
8513 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
8517 case BFD_RELOC_LO16
:
8518 /* When handling an embedded PIC switch statement, we can wind
8519 up deleting a LO16 reloc. See the 'o' case in mips_ip. */
8522 if (value
< -0x8000 || value
> 0x7fff)
8523 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
8524 "relocation overflow");
8525 buf
= (unsigned char *) fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
8526 if (target_big_endian
)
8528 md_number_to_chars (buf
, value
, 2);
8532 case BFD_RELOC_16_PCREL_S2
:
8534 * We need to save the bits in the instruction since fixup_segment()
8535 * might be deleting the relocation entry (i.e., a branch within
8536 * the current segment).
8538 if ((value
& 0x3) != 0)
8539 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
8540 "Branch to odd address (%lx)", value
);
8543 /* update old instruction data */
8544 buf
= (unsigned char *) (fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
);
8545 if (target_big_endian
)
8546 insn
= (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
8548 insn
= (buf
[3] << 24) | (buf
[2] << 16) | (buf
[1] << 8) | buf
[0];
8550 if (value
>= -0x8000 && value
< 0x8000)
8551 insn
|= value
& 0xffff;
8554 /* The branch offset is too large. If this is an
8555 unconditional branch, and we are not generating PIC code,
8556 we can convert it to an absolute jump instruction. */
8557 if (mips_pic
== NO_PIC
8559 && fixP
->fx_frag
->fr_address
>= text_section
->vma
8560 && (fixP
->fx_frag
->fr_address
8561 < text_section
->vma
+ text_section
->_raw_size
)
8562 && ((insn
& 0xffff0000) == 0x10000000 /* beq $0,$0 */
8563 || (insn
& 0xffff0000) == 0x04010000 /* bgez $0 */
8564 || (insn
& 0xffff0000) == 0x04110000)) /* bgezal $0 */
8566 if ((insn
& 0xffff0000) == 0x04110000) /* bgezal $0 */
8567 insn
= 0x0c000000; /* jal */
8569 insn
= 0x08000000; /* j */
8570 fixP
->fx_r_type
= BFD_RELOC_MIPS_JMP
;
8572 fixP
->fx_addsy
= section_symbol (text_section
);
8573 fixP
->fx_addnumber
= (value
<< 2) + md_pcrel_from (fixP
);
8577 /* FIXME. It would be possible in principle to handle
8578 conditional branches which overflow. They could be
8579 transformed into a branch around a jump. This would
8580 require setting up variant frags for each different
8581 branch type. The native MIPS assembler attempts to
8582 handle these cases, but it appears to do it
8584 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
8585 "Relocation overflow");
8589 md_number_to_chars ((char *) buf
, (valueT
) insn
, 4);
8604 const struct mips_opcode
*p
;
8605 int treg
, sreg
, dreg
, shamt
;
8610 for (i
= 0; i
< NUMOPCODES
; ++i
)
8612 p
= &mips_opcodes
[i
];
8613 if (((oc
& p
->mask
) == p
->match
) && (p
->pinfo
!= INSN_MACRO
))
8615 printf ("%08lx %s\t", oc
, p
->name
);
8616 treg
= (oc
>> 16) & 0x1f;
8617 sreg
= (oc
>> 21) & 0x1f;
8618 dreg
= (oc
>> 11) & 0x1f;
8619 shamt
= (oc
>> 6) & 0x1f;
8621 for (args
= p
->args
;; ++args
)
8632 printf ("%c", *args
);
8636 assert (treg
== sreg
);
8637 printf ("$%d,$%d", treg
, sreg
);
8642 printf ("$%d", dreg
);
8647 printf ("$%d", treg
);
8651 printf ("0x%x", treg
);
8656 printf ("$%d", sreg
);
8660 printf ("0x%08lx", oc
& 0x1ffffff);
8672 printf ("$%d", shamt
);
8683 printf ("%08lx UNDEFINED\n", oc
);
8694 name
= input_line_pointer
;
8695 c
= get_symbol_end ();
8696 p
= (symbolS
*) symbol_find_or_make (name
);
8697 *input_line_pointer
= c
;
8701 /* Align the current frag to a given power of two. The MIPS assembler
8702 also automatically adjusts any preceding label. */
8705 mips_align (to
, fill
, label
)
8710 mips_emit_delays (false);
8711 frag_align (to
, fill
);
8712 record_alignment (now_seg
, to
);
8715 assert (S_GET_SEGMENT (label
) == now_seg
);
8716 label
->sy_frag
= frag_now
;
8717 S_SET_VALUE (label
, (valueT
) frag_now_fix ());
8721 /* Align to a given power of two. .align 0 turns off the automatic
8722 alignment used by the data creating pseudo-ops. */
8729 register long temp_fill
;
8730 long max_alignment
= 15;
8734 o Note that the assembler pulls down any immediately preceeding label
8735 to the aligned address.
8736 o It's not documented but auto alignment is reinstated by
8737 a .align pseudo instruction.
8738 o Note also that after auto alignment is turned off the mips assembler
8739 issues an error on attempt to assemble an improperly aligned data item.
8744 temp
= get_absolute_expression ();
8745 if (temp
> max_alignment
)
8746 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
8749 as_warn ("Alignment negative: 0 assumed.");
8752 if (*input_line_pointer
== ',')
8754 input_line_pointer
++;
8755 temp_fill
= get_absolute_expression ();
8762 mips_align (temp
, (int) temp_fill
,
8763 insn_labels
!= NULL
? insn_labels
->label
: NULL
);
8770 demand_empty_rest_of_line ();
8774 mips_flush_pending_output ()
8776 mips_emit_delays (false);
8777 mips_clear_insn_labels ();
8786 /* When generating embedded PIC code, we only use the .text, .lit8,
8787 .sdata and .sbss sections. We change the .data and .rdata
8788 pseudo-ops to use .sdata. */
8789 if (mips_pic
== EMBEDDED_PIC
8790 && (sec
== 'd' || sec
== 'r'))
8793 mips_emit_delays (false);
8803 subseg_set (bss_section
, (subsegT
) get_absolute_expression ());
8804 demand_empty_rest_of_line ();
8808 if (USE_GLOBAL_POINTER_OPT
)
8810 seg
= subseg_new (RDATA_SECTION_NAME
,
8811 (subsegT
) get_absolute_expression ());
8812 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
8814 bfd_set_section_flags (stdoutput
, seg
,
8820 if (strcmp (TARGET_OS
, "elf") != 0)
8821 bfd_set_section_alignment (stdoutput
, seg
, 4);
8823 demand_empty_rest_of_line ();
8827 as_bad ("No read only data section in this object file format");
8828 demand_empty_rest_of_line ();
8834 if (USE_GLOBAL_POINTER_OPT
)
8836 seg
= subseg_new (".sdata", (subsegT
) get_absolute_expression ());
8837 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
8839 bfd_set_section_flags (stdoutput
, seg
,
8840 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
8842 if (strcmp (TARGET_OS
, "elf") != 0)
8843 bfd_set_section_alignment (stdoutput
, seg
, 4);
8845 demand_empty_rest_of_line ();
8850 as_bad ("Global pointers not supported; recompile -G 0");
8851 demand_empty_rest_of_line ();
8860 mips_enable_auto_align ()
8871 label
= insn_labels
!= NULL
? insn_labels
->label
: NULL
;
8872 mips_emit_delays (false);
8873 if (log_size
> 0 && auto_align
)
8874 mips_align (log_size
, 0, label
);
8875 mips_clear_insn_labels ();
8876 cons (1 << log_size
);
8885 label
= insn_labels
!= NULL
? insn_labels
->label
: NULL
;
8887 mips_emit_delays (false);
8891 mips_align (3, 0, label
);
8893 mips_align (2, 0, label
);
8895 mips_clear_insn_labels ();
8900 /* Handle .globl. We need to override it because on Irix 5 you are
8903 where foo is an undefined symbol, to mean that foo should be
8904 considered to be the address of a function. */
8915 name
= input_line_pointer
;
8916 c
= get_symbol_end ();
8917 symbolP
= symbol_find_or_make (name
);
8918 *input_line_pointer
= c
;
8921 /* On Irix 5, every global symbol that is not explicitly labelled as
8922 being a function is apparently labelled as being an object. */
8925 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
8930 secname
= input_line_pointer
;
8931 c
= get_symbol_end ();
8932 sec
= bfd_get_section_by_name (stdoutput
, secname
);
8934 as_bad ("%s: no such section", secname
);
8935 *input_line_pointer
= c
;
8937 if (sec
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
8938 flag
= BSF_FUNCTION
;
8941 symbolP
->bsym
->flags
|= flag
;
8943 S_SET_EXTERNAL (symbolP
);
8944 demand_empty_rest_of_line ();
8954 opt
= input_line_pointer
;
8955 c
= get_symbol_end ();
8959 /* FIXME: What does this mean? */
8961 else if (strncmp (opt
, "pic", 3) == 0)
8969 mips_pic
= SVR4_PIC
;
8971 as_bad (".option pic%d not supported", i
);
8973 if (USE_GLOBAL_POINTER_OPT
&& mips_pic
== SVR4_PIC
)
8975 if (g_switch_seen
&& g_switch_value
!= 0)
8976 as_warn ("-G may not be used with SVR4 PIC code");
8978 bfd_set_gp_size (stdoutput
, 0);
8982 as_warn ("Unrecognized option \"%s\"", opt
);
8984 *input_line_pointer
= c
;
8985 demand_empty_rest_of_line ();
8992 char *name
= input_line_pointer
, ch
;
8994 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
8995 input_line_pointer
++;
8996 ch
= *input_line_pointer
;
8997 *input_line_pointer
= '\0';
8999 if (strcmp (name
, "reorder") == 0)
9003 prev_insn_unreordered
= 1;
9004 prev_prev_insn_unreordered
= 1;
9008 else if (strcmp (name
, "noreorder") == 0)
9010 mips_emit_delays (true);
9012 mips_any_noreorder
= 1;
9014 else if (strcmp (name
, "at") == 0)
9018 else if (strcmp (name
, "noat") == 0)
9022 else if (strcmp (name
, "macro") == 0)
9024 mips_warn_about_macros
= 0;
9026 else if (strcmp (name
, "nomacro") == 0)
9028 if (mips_noreorder
== 0)
9029 as_bad ("`noreorder' must be set before `nomacro'");
9030 mips_warn_about_macros
= 1;
9032 else if (strcmp (name
, "move") == 0 || strcmp (name
, "novolatile") == 0)
9036 else if (strcmp (name
, "nomove") == 0 || strcmp (name
, "volatile") == 0)
9040 else if (strcmp (name
, "bopt") == 0)
9044 else if (strcmp (name
, "nobopt") == 0)
9048 else if (strcmp (name
, "mips16") == 0
9049 || strcmp (name
, "MIPS-16") == 0)
9051 else if (strcmp (name
, "nomips16") == 0
9052 || strcmp (name
, "noMIPS-16") == 0)
9054 else if (strncmp (name
, "mips", 4) == 0)
9058 /* Permit the user to change the ISA on the fly. Needless to
9059 say, misuse can cause serious problems. */
9060 isa
= atoi (name
+ 4);
9062 mips_isa
= file_mips_isa
;
9063 else if (isa
< 1 || isa
> 4)
9064 as_bad ("unknown ISA level");
9068 else if (strcmp (name
, "autoextend") == 0)
9069 mips16_autoextend
= 1;
9070 else if (strcmp (name
, "noautoextend") == 0)
9071 mips16_autoextend
= 0;
9074 as_warn ("Tried to set unrecognized symbol: %s\n", name
);
9076 *input_line_pointer
= ch
;
9077 demand_empty_rest_of_line ();
9080 /* Handle the .abicalls pseudo-op. I believe this is equivalent to
9081 .option pic2. It means to generate SVR4 PIC calls. */
9087 mips_pic
= SVR4_PIC
;
9088 if (USE_GLOBAL_POINTER_OPT
)
9090 if (g_switch_seen
&& g_switch_value
!= 0)
9091 as_warn ("-G may not be used with SVR4 PIC code");
9094 bfd_set_gp_size (stdoutput
, 0);
9095 demand_empty_rest_of_line ();
9098 /* Handle the .cpload pseudo-op. This is used when generating SVR4
9099 PIC code. It sets the $gp register for the function based on the
9100 function address, which is in the register named in the argument.
9101 This uses a relocation against _gp_disp, which is handled specially
9102 by the linker. The result is:
9103 lui $gp,%hi(_gp_disp)
9104 addiu $gp,$gp,%lo(_gp_disp)
9105 addu $gp,$gp,.cpload argument
9106 The .cpload argument is normally $25 == $t9. */
9115 /* If we are not generating SVR4 PIC code, .cpload is ignored. */
9116 if (mips_pic
!= SVR4_PIC
)
9122 /* .cpload should be a in .set noreorder section. */
9123 if (mips_noreorder
== 0)
9124 as_warn (".cpload not in noreorder section");
9127 ex
.X_add_symbol
= symbol_find_or_make ("_gp_disp");
9128 ex
.X_op_symbol
= NULL
;
9129 ex
.X_add_number
= 0;
9131 /* In ELF, this symbol is implicitly an STT_OBJECT symbol. */
9132 ex
.X_add_symbol
->bsym
->flags
|= BSF_OBJECT
;
9134 macro_build_lui ((char *) NULL
, &icnt
, &ex
, GP
);
9135 macro_build ((char *) NULL
, &icnt
, &ex
, "addiu", "t,r,j", GP
, GP
,
9136 (int) BFD_RELOC_LO16
);
9138 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
, "addu", "d,v,t",
9139 GP
, GP
, tc_get_register (0));
9141 demand_empty_rest_of_line ();
9144 /* Handle the .cprestore pseudo-op. This stores $gp into a given
9145 offset from $sp. The offset is remembered, and after making a PIC
9146 call $gp is restored from that location. */
9149 s_cprestore (ignore
)
9155 /* If we are not generating SVR4 PIC code, .cprestore is ignored. */
9156 if (mips_pic
!= SVR4_PIC
)
9162 mips_cprestore_offset
= get_absolute_expression ();
9164 ex
.X_op
= O_constant
;
9165 ex
.X_add_symbol
= NULL
;
9166 ex
.X_op_symbol
= NULL
;
9167 ex
.X_add_number
= mips_cprestore_offset
;
9169 macro_build ((char *) NULL
, &icnt
, &ex
,
9170 mips_isa
< 3 ? "sw" : "sd",
9171 "t,o(b)", GP
, (int) BFD_RELOC_LO16
, SP
);
9173 demand_empty_rest_of_line ();
9176 /* Handle the .gpword pseudo-op. This is used when generating PIC
9177 code. It generates a 32 bit GP relative reloc. */
9187 /* When not generating PIC code, this is treated as .word. */
9188 if (mips_pic
!= SVR4_PIC
)
9194 label
= insn_labels
!= NULL
? insn_labels
->label
: NULL
;
9195 mips_emit_delays (true);
9197 mips_align (2, 0, label
);
9198 mips_clear_insn_labels ();
9202 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
9204 as_bad ("Unsupported use of .gpword");
9205 ignore_rest_of_line ();
9209 md_number_to_chars (p
, (valueT
) 0, 4);
9210 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4, &ex
, 0,
9211 BFD_RELOC_MIPS_GPREL32
);
9213 demand_empty_rest_of_line ();
9216 /* Handle the .cpadd pseudo-op. This is used when dealing with switch
9217 tables in SVR4 PIC code. */
9226 /* This is ignored when not generating SVR4 PIC code. */
9227 if (mips_pic
!= SVR4_PIC
)
9233 /* Add $gp to the register named as an argument. */
9234 reg
= tc_get_register (0);
9235 macro_build ((char *) NULL
, &icnt
, (expressionS
*) NULL
,
9236 mips_isa
< 3 ? "addu" : "daddu",
9237 "d,v,t", reg
, reg
, GP
);
9239 demand_empty_rest_of_line ();
9242 /* Handle the .insn pseudo-op. This marks instruction labels in
9243 mips16 mode. This permits the linker to handle them specially,
9244 such as generating jalx instructions when needed. We also make
9245 them odd for the duration of the assembly, in order to generate the
9246 right sort of code. We will make them even in the adjust_symtab
9247 routine, while leaving them marked. This is convenient for the
9248 debugger and the disassembler. The linker knows to make them odd
9257 struct insn_label_list
*l
;
9259 for (l
= insn_labels
; l
!= NULL
; l
= l
->next
)
9262 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
9263 S_SET_OTHER (l
->label
, STO_MIPS16
);
9265 ++l
->label
->sy_value
.X_add_number
;
9268 mips_clear_insn_labels ();
9271 demand_empty_rest_of_line ();
9274 /* Parse a register string into a number. Called from the ECOFF code
9275 to parse .frame. The argument is non-zero if this is the frame
9276 register, so that we can record it in mips_frame_reg. */
9279 tc_get_register (frame
)
9285 if (*input_line_pointer
++ != '$')
9287 as_warn ("expected `$'");
9290 else if (isdigit ((unsigned char) *input_line_pointer
))
9292 reg
= get_absolute_expression ();
9293 if (reg
< 0 || reg
>= 32)
9295 as_warn ("Bad register number");
9301 if (strncmp (input_line_pointer
, "fp", 2) == 0)
9303 else if (strncmp (input_line_pointer
, "sp", 2) == 0)
9305 else if (strncmp (input_line_pointer
, "gp", 2) == 0)
9307 else if (strncmp (input_line_pointer
, "at", 2) == 0)
9311 as_warn ("Unrecognized register name");
9314 input_line_pointer
+= 2;
9317 mips_frame_reg
= reg
!= 0 ? reg
: SP
;
9322 md_section_align (seg
, addr
)
9326 int align
= bfd_get_section_alignment (stdoutput
, seg
);
9329 /* We don't need to align ELF sections to the full alignment.
9330 However, Irix 5 may prefer that we align them at least to a 16
9331 byte boundary. We don't bother to align the sections if we are
9332 targeted for an embedded system. */
9333 if (strcmp (TARGET_OS
, "elf") == 0)
9339 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
9342 /* Utility routine, called from above as well. If called while the
9343 input file is still being read, it's only an approximation. (For
9344 example, a symbol may later become defined which appeared to be
9345 undefined earlier.) */
9348 nopic_need_relax (sym
)
9354 if (USE_GLOBAL_POINTER_OPT
)
9356 const char *symname
;
9359 /* Find out whether this symbol can be referenced off the GP
9360 register. It can be if it is smaller than the -G size or if
9361 it is in the .sdata or .sbss section. Certain symbols can
9362 not be referenced off the GP, although it appears as though
9364 symname
= S_GET_NAME (sym
);
9365 if (symname
!= (const char *) NULL
9366 && (strcmp (symname
, "eprol") == 0
9367 || strcmp (symname
, "etext") == 0
9368 || strcmp (symname
, "_gp") == 0
9369 || strcmp (symname
, "edata") == 0
9370 || strcmp (symname
, "_fbss") == 0
9371 || strcmp (symname
, "_fdata") == 0
9372 || strcmp (symname
, "_ftext") == 0
9373 || strcmp (symname
, "end") == 0
9374 || strcmp (symname
, "_gp_disp") == 0))
9376 else if (! S_IS_DEFINED (sym
)
9378 #ifndef NO_ECOFF_DEBUGGING
9379 || (sym
->ecoff_extern_size
!= 0
9380 && sym
->ecoff_extern_size
<= g_switch_value
)
9382 || (S_GET_VALUE (sym
) != 0
9383 && S_GET_VALUE (sym
) <= g_switch_value
)))
9387 const char *segname
;
9389 segname
= segment_name (S_GET_SEGMENT (sym
));
9390 assert (strcmp (segname
, ".lit8") != 0
9391 && strcmp (segname
, ".lit4") != 0);
9392 change
= (strcmp (segname
, ".sdata") != 0
9393 && strcmp (segname
, ".sbss") != 0);
9398 /* We are not optimizing for the GP register. */
9402 /* Given a mips16 variant frag FRAGP, return non-zero if it needs an
9403 extended opcode. SEC is the section the frag is in. */
9406 mips16_extended_frag (fragp
, sec
, stretch
)
9412 register const struct mips16_immed_operand
*op
;
9414 int mintiny
, maxtiny
;
9417 if (RELAX_MIPS16_USER_SMALL (fragp
->fr_subtype
))
9419 if (RELAX_MIPS16_USER_EXT (fragp
->fr_subtype
))
9422 type
= RELAX_MIPS16_TYPE (fragp
->fr_subtype
);
9423 op
= mips16_immed_operands
;
9424 while (op
->type
!= type
)
9427 assert (op
< mips16_immed_operands
+ MIPS16_NUM_IMMED
);
9432 if (type
== '<' || type
== '>' || type
== '[' || type
== ']')
9435 maxtiny
= 1 << op
->nbits
;
9440 maxtiny
= (1 << op
->nbits
) - 1;
9445 mintiny
= - (1 << (op
->nbits
- 1));
9446 maxtiny
= (1 << (op
->nbits
- 1)) - 1;
9449 /* We can't call S_GET_VALUE here, because we don't want to lock in
9450 a particular frag address. */
9451 if (fragp
->fr_symbol
->sy_value
.X_op
== O_constant
)
9453 val
= (fragp
->fr_symbol
->sy_value
.X_add_number
9454 + fragp
->fr_symbol
->sy_frag
->fr_address
);
9455 symsec
= S_GET_SEGMENT (fragp
->fr_symbol
);
9457 else if (fragp
->fr_symbol
->sy_value
.X_op
== O_symbol
9458 && (fragp
->fr_symbol
->sy_value
.X_add_symbol
->sy_value
.X_op
9461 val
= (fragp
->fr_symbol
->sy_value
.X_add_symbol
->sy_value
.X_add_number
9462 + fragp
->fr_symbol
->sy_value
.X_add_symbol
->sy_frag
->fr_address
9463 + fragp
->fr_symbol
->sy_value
.X_add_number
9464 + fragp
->fr_symbol
->sy_frag
->fr_address
);
9465 symsec
= S_GET_SEGMENT (fragp
->fr_symbol
->sy_value
.X_add_symbol
);
9474 /* We won't have the section when we are called from
9475 mips_relax_frag. However, we will always have been called
9476 from md_estimate_size_before_relax first. If this is a
9477 branch to a different section, we mark it as such. If SEC is
9478 NULL, and the frag is not marked, then it must be a branch to
9479 the same section. */
9482 if (RELAX_MIPS16_LONG_BRANCH (fragp
->fr_subtype
))
9490 RELAX_MIPS16_MARK_LONG_BRANCH (fragp
->fr_subtype
);
9492 /* FIXME: We should support this, and let the linker
9493 catch branches and loads that are out of range. */
9494 as_bad_where (fragp
->fr_file
, fragp
->fr_line
,
9495 "unsupported PC relative reference to different section");
9501 /* In this case, we know for sure that the symbol fragment is in
9502 the same section. If the fr_address of the symbol fragment
9503 is greater then the address of this fragment we want to add
9504 in STRETCH in order to get a better estimate of the address.
9505 This particularly matters because of the shift bits. */
9507 && fragp
->fr_symbol
->sy_frag
->fr_address
>= fragp
->fr_address
)
9511 /* Adjust stretch for any alignment frag. */
9512 for (f
= fragp
; f
!= fragp
->fr_symbol
->sy_frag
; f
= f
->fr_next
)
9515 if (f
->fr_type
== rs_align
|| f
->fr_type
== rs_align_code
)
9518 stretch
= - ((- stretch
)
9519 & ~ ((1 << (int) f
->fr_offset
) - 1));
9521 stretch
&= ~ ((1 << (int) f
->fr_offset
) - 1);
9529 addr
= fragp
->fr_address
+ fragp
->fr_fix
;
9531 /* The base address rules are complicated. The base address of
9532 a branch is the following instruction. The base address of a
9533 PC relative load or add is the instruction itself, but if it
9534 is extended add 2, and if it is in a delay slot (in which
9535 case it can not be extended) use the address of the
9536 instruction whose delay slot it is in. */
9537 if (type
== 'p' || type
== 'q')
9540 /* Ignore the low bit in the target, since it will be set
9541 for a text label. */
9545 else if (RELAX_MIPS16_JAL_DSLOT (fragp
->fr_subtype
))
9547 else if (RELAX_MIPS16_DSLOT (fragp
->fr_subtype
))
9550 /* If we are currently assuming that this frag should be
9551 extended, then the current address is two bytes higher. */
9552 if (RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
))
9555 val
-= addr
& ~ ((1 << op
->shift
) - 1);
9557 /* Branch offsets have an implicit 0 in the lowest bit. */
9558 if (type
== 'p' || type
== 'q')
9561 /* If any of the shifted bits are set, we must use an extended
9562 opcode. If the address depends on the size of this
9563 instruction, this can lead to a loop, so we arrange to always
9564 use an extended opcode. We only check this when we are in
9565 the main relaxation loop, when SEC is NULL. */
9566 if ((val
& ((1 << op
->shift
) - 1)) != 0 && sec
== NULL
)
9569 RELAX_MIPS16_MARK_LONG_BRANCH (fragp
->fr_subtype
);
9573 /* If we are about to mark a frag as extended because the value
9574 is precisely maxtiny + 1, then there is a chance of an
9575 infinite loop as in the following code:
9580 In this case when the la is extended, foo is 0x3fc bytes
9581 away, so the la can be shrunk, but then foo is 0x400 away, so
9582 the la must be extended. To avoid this loop, we mark the
9583 frag as extended if it was small, and is about to become
9584 extended with a value of maxtiny + 1. */
9585 if (val
== ((maxtiny
+ 1) << op
->shift
)
9586 && ! RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
)
9590 RELAX_MIPS16_MARK_LONG_BRANCH (fragp
->fr_subtype
);
9594 else if (symsec
!= absolute_section
&& sec
!= NULL
)
9595 as_bad_where (fragp
->fr_file
, fragp
->fr_line
, "unsupported relocation");
9597 if ((val
& ((1 << op
->shift
) - 1)) != 0
9598 || val
< (mintiny
<< op
->shift
)
9599 || val
> (maxtiny
<< op
->shift
))
9605 /* Estimate the size of a frag before relaxing. Unless this is the
9606 mips16, we are not really relaxing here, and the final size is
9607 encoded in the subtype information. For the mips16, we have to
9608 decide whether we are using an extended opcode or not. */
9612 md_estimate_size_before_relax (fragp
, segtype
)
9618 if (RELAX_MIPS16_P (fragp
->fr_subtype
))
9620 if (mips16_extended_frag (fragp
, segtype
, 0))
9622 fragp
->fr_subtype
= RELAX_MIPS16_MARK_EXTENDED (fragp
->fr_subtype
);
9627 fragp
->fr_subtype
= RELAX_MIPS16_CLEAR_EXTENDED (fragp
->fr_subtype
);
9632 if (mips_pic
== NO_PIC
)
9634 change
= nopic_need_relax (fragp
->fr_symbol
);
9636 else if (mips_pic
== SVR4_PIC
)
9638 asection
*symsec
= fragp
->fr_symbol
->bsym
->section
;
9640 /* This must duplicate the test in adjust_reloc_syms. */
9641 change
= (symsec
!= &bfd_und_section
9642 && symsec
!= &bfd_abs_section
9643 && ! bfd_is_com_section (symsec
));
9650 /* Record the offset to the first reloc in the fr_opcode field.
9651 This lets md_convert_frag and tc_gen_reloc know that the code
9652 must be expanded. */
9653 fragp
->fr_opcode
= (fragp
->fr_literal
9655 - RELAX_OLD (fragp
->fr_subtype
)
9656 + RELAX_RELOC1 (fragp
->fr_subtype
));
9657 /* FIXME: This really needs as_warn_where. */
9658 if (RELAX_WARN (fragp
->fr_subtype
))
9659 as_warn ("AT used after \".set noat\" or macro used after \".set nomacro\"");
9665 return RELAX_NEW (fragp
->fr_subtype
) - RELAX_OLD (fragp
->fr_subtype
);
9668 /* This is called to see whether a reloc against a defined symbol
9669 should be converted into a reloc against a section. Don't adjust
9670 MIPS16 jump relocations, so we don't have to worry about the format
9671 of the offset in the .o file. Don't adjust relocations against
9672 mips16 symbols, so that the linker can find them if it needs to set
9676 mips_fix_adjustable (fixp
)
9679 if (fixp
->fx_r_type
== BFD_RELOC_MIPS16_JMP
)
9681 if (fixp
->fx_addsy
== NULL
)
9684 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
9685 && S_GET_OTHER (fixp
->fx_addsy
) == STO_MIPS16
)
9691 /* Translate internal representation of relocation info to BFD target
9695 tc_gen_reloc (section
, fixp
)
9699 static arelent
*retval
[4];
9701 bfd_reloc_code_real_type code
;
9703 reloc
= retval
[0] = (arelent
*) xmalloc (sizeof (arelent
));
9706 reloc
->sym_ptr_ptr
= &fixp
->fx_addsy
->bsym
;
9707 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
9709 if (mips_pic
== EMBEDDED_PIC
9710 && SWITCH_TABLE (fixp
))
9712 /* For a switch table entry we use a special reloc. The addend
9713 is actually the difference between the reloc address and the
9715 reloc
->addend
= reloc
->address
- S_GET_VALUE (fixp
->fx_subsy
);
9716 if (OUTPUT_FLAVOR
!= bfd_target_ecoff_flavour
)
9717 as_fatal ("Double check fx_r_type in tc-mips.c:tc_gen_reloc");
9718 fixp
->fx_r_type
= BFD_RELOC_GPREL32
;
9720 else if (fixp
->fx_r_type
== BFD_RELOC_PCREL_LO16
)
9722 /* We use a special addend for an internal RELLO reloc. */
9723 if (fixp
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
)
9724 reloc
->addend
= reloc
->address
- S_GET_VALUE (fixp
->fx_subsy
);
9726 reloc
->addend
= fixp
->fx_addnumber
+ reloc
->address
;
9728 else if (fixp
->fx_r_type
== BFD_RELOC_PCREL_HI16_S
)
9730 assert (fixp
->fx_next
!= NULL
9731 && fixp
->fx_next
->fx_r_type
== BFD_RELOC_PCREL_LO16
);
9732 /* We use a special addend for an internal RELHI reloc. The
9733 reloc is relative to the RELLO; adjust the addend
9735 if (fixp
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
)
9736 reloc
->addend
= (fixp
->fx_next
->fx_frag
->fr_address
9737 + fixp
->fx_next
->fx_where
9738 - S_GET_VALUE (fixp
->fx_subsy
));
9740 reloc
->addend
= (fixp
->fx_addnumber
9741 + fixp
->fx_next
->fx_frag
->fr_address
9742 + fixp
->fx_next
->fx_where
);
9744 else if (fixp
->fx_pcrel
== 0)
9745 reloc
->addend
= fixp
->fx_addnumber
;
9748 if (OUTPUT_FLAVOR
!= bfd_target_aout_flavour
)
9749 /* A gruesome hack which is a result of the gruesome gas reloc
9751 reloc
->addend
= reloc
->address
;
9753 reloc
->addend
= -reloc
->address
;
9756 /* If this is a variant frag, we may need to adjust the existing
9757 reloc and generate a new one. */
9758 if (fixp
->fx_frag
->fr_opcode
!= NULL
9759 && (fixp
->fx_r_type
== BFD_RELOC_MIPS_GPREL
9760 || fixp
->fx_r_type
== BFD_RELOC_MIPS_GOT16
9761 || fixp
->fx_r_type
== BFD_RELOC_MIPS_CALL16
9762 || fixp
->fx_r_type
== BFD_RELOC_MIPS_GOT_HI16
9763 || fixp
->fx_r_type
== BFD_RELOC_MIPS_GOT_LO16
9764 || fixp
->fx_r_type
== BFD_RELOC_MIPS_CALL_HI16
9765 || fixp
->fx_r_type
== BFD_RELOC_MIPS_CALL_LO16
))
9769 assert (! RELAX_MIPS16_P (fixp
->fx_frag
->fr_subtype
));
9771 /* If this is not the last reloc in this frag, then we have two
9772 GPREL relocs, or a GOT_HI16/GOT_LO16 pair, or a
9773 CALL_HI16/CALL_LO16, both of which are being replaced. Let
9774 the second one handle all of them. */
9775 if (fixp
->fx_next
!= NULL
9776 && fixp
->fx_frag
== fixp
->fx_next
->fx_frag
)
9778 assert ((fixp
->fx_r_type
== BFD_RELOC_MIPS_GPREL
9779 && fixp
->fx_next
->fx_r_type
== BFD_RELOC_MIPS_GPREL
)
9780 || (fixp
->fx_r_type
== BFD_RELOC_MIPS_GOT_HI16
9781 && (fixp
->fx_next
->fx_r_type
9782 == BFD_RELOC_MIPS_GOT_LO16
))
9783 || (fixp
->fx_r_type
== BFD_RELOC_MIPS_CALL_HI16
9784 && (fixp
->fx_next
->fx_r_type
9785 == BFD_RELOC_MIPS_CALL_LO16
)));
9790 fixp
->fx_where
= fixp
->fx_frag
->fr_opcode
- fixp
->fx_frag
->fr_literal
;
9791 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
9792 reloc2
= retval
[1] = (arelent
*) xmalloc (sizeof (arelent
));
9794 reloc2
->sym_ptr_ptr
= &fixp
->fx_addsy
->bsym
;
9795 reloc2
->address
= (reloc
->address
9796 + (RELAX_RELOC2 (fixp
->fx_frag
->fr_subtype
)
9797 - RELAX_RELOC1 (fixp
->fx_frag
->fr_subtype
)));
9798 reloc2
->addend
= fixp
->fx_addnumber
;
9799 reloc2
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_LO16
);
9800 assert (reloc2
->howto
!= NULL
);
9802 if (RELAX_RELOC3 (fixp
->fx_frag
->fr_subtype
))
9806 reloc3
= retval
[2] = (arelent
*) xmalloc (sizeof (arelent
));
9809 reloc3
->address
+= 4;
9812 if (mips_pic
== NO_PIC
)
9814 assert (fixp
->fx_r_type
== BFD_RELOC_MIPS_GPREL
);
9815 fixp
->fx_r_type
= BFD_RELOC_HI16_S
;
9817 else if (mips_pic
== SVR4_PIC
)
9819 switch (fixp
->fx_r_type
)
9823 case BFD_RELOC_MIPS_GOT16
:
9825 case BFD_RELOC_MIPS_CALL16
:
9826 case BFD_RELOC_MIPS_GOT_LO16
:
9827 case BFD_RELOC_MIPS_CALL_LO16
:
9828 fixp
->fx_r_type
= BFD_RELOC_MIPS_GOT16
;
9836 /* Since DIFF_EXPR_OK is defined in tc-mips.h, it is possible that
9837 fixup_segment converted a non-PC relative reloc into a PC
9838 relative reloc. In such a case, we need to convert the reloc
9840 code
= fixp
->fx_r_type
;
9846 code
= BFD_RELOC_8_PCREL
;
9849 code
= BFD_RELOC_16_PCREL
;
9852 code
= BFD_RELOC_32_PCREL
;
9855 code
= BFD_RELOC_64_PCREL
;
9857 case BFD_RELOC_8_PCREL
:
9858 case BFD_RELOC_16_PCREL
:
9859 case BFD_RELOC_32_PCREL
:
9860 case BFD_RELOC_64_PCREL
:
9861 case BFD_RELOC_16_PCREL_S2
:
9862 case BFD_RELOC_PCREL_HI16_S
:
9863 case BFD_RELOC_PCREL_LO16
:
9866 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
9867 "Cannot make %s relocation PC relative",
9868 bfd_get_reloc_code_name (code
));
9872 /* To support a PC relative reloc when generating embedded PIC code
9873 for ECOFF, we use a Cygnus extension. We check for that here to
9874 make sure that we don't let such a reloc escape normally. */
9875 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
9876 && code
== BFD_RELOC_16_PCREL_S2
9877 && mips_pic
!= EMBEDDED_PIC
)
9878 reloc
->howto
= NULL
;
9880 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
9882 if (reloc
->howto
== NULL
)
9884 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
9885 "Can not represent %s relocation in this object file format",
9886 bfd_get_reloc_code_name (code
));
9893 /* Relax a machine dependent frag. This returns the amount by which
9894 the current size of the frag should change. */
9897 mips_relax_frag (fragp
, stretch
)
9901 if (! RELAX_MIPS16_P (fragp
->fr_subtype
))
9904 if (mips16_extended_frag (fragp
, (asection
*) NULL
, stretch
))
9906 if (RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
))
9908 fragp
->fr_subtype
= RELAX_MIPS16_MARK_EXTENDED (fragp
->fr_subtype
);
9913 if (! RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
))
9915 fragp
->fr_subtype
= RELAX_MIPS16_CLEAR_EXTENDED (fragp
->fr_subtype
);
9922 /* Convert a machine dependent frag. */
9925 md_convert_frag (abfd
, asec
, fragp
)
9933 if (RELAX_MIPS16_P (fragp
->fr_subtype
))
9936 register const struct mips16_immed_operand
*op
;
9942 unsigned short extend
;
9944 type
= RELAX_MIPS16_TYPE (fragp
->fr_subtype
);
9945 op
= mips16_immed_operands
;
9946 while (op
->type
!= type
)
9949 if (RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
))
9960 resolve_symbol_value (fragp
->fr_symbol
);
9961 val
= S_GET_VALUE (fragp
->fr_symbol
);
9966 addr
= fragp
->fr_address
+ fragp
->fr_fix
;
9968 /* The rules for the base address of a PC relative reloc are
9969 complicated; see mips16_extended_frag. */
9970 if (type
== 'p' || type
== 'q')
9973 /* Ignore the low bit in the target, since it will be
9974 set for a text label. */
9978 else if (RELAX_MIPS16_JAL_DSLOT (fragp
->fr_subtype
))
9980 else if (RELAX_MIPS16_DSLOT (fragp
->fr_subtype
))
9985 addr
&= ~ (addressT
) ((1 << op
->shift
) - 1);
9988 /* Make sure the section winds up with the alignment we have
9991 record_alignment (asec
, op
->shift
);
9995 && (RELAX_MIPS16_JAL_DSLOT (fragp
->fr_subtype
)
9996 || RELAX_MIPS16_DSLOT (fragp
->fr_subtype
)))
9997 as_warn_where (fragp
->fr_file
, fragp
->fr_line
,
9998 "extended instruction in delay slot");
10000 buf
= (bfd_byte
*) (fragp
->fr_literal
+ fragp
->fr_fix
);
10002 if (target_big_endian
)
10003 insn
= bfd_getb16 (buf
);
10005 insn
= bfd_getl16 (buf
);
10007 mips16_immed (fragp
->fr_file
, fragp
->fr_line
, type
, val
,
10008 RELAX_MIPS16_USER_EXT (fragp
->fr_subtype
),
10009 small
, ext
, &insn
, &use_extend
, &extend
);
10013 md_number_to_chars (buf
, 0xf000 | extend
, 2);
10014 fragp
->fr_fix
+= 2;
10018 md_number_to_chars (buf
, insn
, 2);
10019 fragp
->fr_fix
+= 2;
10024 if (fragp
->fr_opcode
== NULL
)
10027 old
= RELAX_OLD (fragp
->fr_subtype
);
10028 new = RELAX_NEW (fragp
->fr_subtype
);
10029 fixptr
= fragp
->fr_literal
+ fragp
->fr_fix
;
10032 memcpy (fixptr
- old
, fixptr
, new);
10034 fragp
->fr_fix
+= new - old
;
10040 /* This function is called after the relocs have been generated.
10041 We've been storing mips16 text labels as odd. Here we convert them
10042 back to even for the convenience of the debugger. */
10045 mips_frob_file_after_relocs ()
10048 unsigned int count
, i
;
10050 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
10053 syms
= bfd_get_outsymbols (stdoutput
);
10054 count
= bfd_get_symcount (stdoutput
);
10055 for (i
= 0; i
< count
; i
++, syms
++)
10057 if (elf_symbol (*syms
)->internal_elf_sym
.st_other
== STO_MIPS16
10058 && ((*syms
)->value
& 1) != 0)
10060 (*syms
)->value
&= ~1;
10061 /* If the symbol has an odd size, it was probably computed
10062 incorrectly, so adjust that as well. */
10063 if ((elf_symbol (*syms
)->internal_elf_sym
.st_size
& 1) != 0)
10064 ++elf_symbol (*syms
)->internal_elf_sym
.st_size
;
10071 /* This function is called whenever a label is defined. It is used
10072 when handling branch delays; if a branch has a label, we assume we
10073 can not move it. */
10076 mips_define_label (sym
)
10079 struct insn_label_list
*l
;
10081 if (free_insn_labels
== NULL
)
10082 l
= (struct insn_label_list
*) xmalloc (sizeof *l
);
10085 l
= free_insn_labels
;
10086 free_insn_labels
= l
->next
;
10090 l
->next
= insn_labels
;
10094 /* Decide whether a label is local. This is called by LOCAL_LABEL.
10095 In order to work with gcc when using mips-tfile, we must keep all
10096 local labels. However, in other cases, we want to discard them,
10097 since they are useless. */
10100 mips_local_label (name
)
10103 #ifndef NO_ECOFF_DEBUGGING
10104 if (ECOFF_DEBUGGING
10106 && ! ecoff_debugging_seen
)
10108 /* We were called with -g, but we didn't see any debugging
10109 information. That may mean that gcc is smuggling debugging
10110 information through to mips-tfile, in which case we must
10111 generate all local labels. */
10116 /* Here it's OK to discard local labels. */
10118 return name
[0] == '$';
10121 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10123 /* Some special processing for a MIPS ELF file. */
10126 mips_elf_final_processing ()
10128 /* Write out the register information. */
10133 s
.ri_gprmask
= mips_gprmask
;
10134 s
.ri_cprmask
[0] = mips_cprmask
[0];
10135 s
.ri_cprmask
[1] = mips_cprmask
[1];
10136 s
.ri_cprmask
[2] = mips_cprmask
[2];
10137 s
.ri_cprmask
[3] = mips_cprmask
[3];
10138 /* The gp_value field is set by the MIPS ELF backend. */
10140 bfd_mips_elf32_swap_reginfo_out (stdoutput
, &s
,
10141 ((Elf32_External_RegInfo
*)
10142 mips_regmask_frag
));
10146 Elf64_Internal_RegInfo s
;
10148 s
.ri_gprmask
= mips_gprmask
;
10150 s
.ri_cprmask
[0] = mips_cprmask
[0];
10151 s
.ri_cprmask
[1] = mips_cprmask
[1];
10152 s
.ri_cprmask
[2] = mips_cprmask
[2];
10153 s
.ri_cprmask
[3] = mips_cprmask
[3];
10154 /* The gp_value field is set by the MIPS ELF backend. */
10156 bfd_mips_elf64_swap_reginfo_out (stdoutput
, &s
,
10157 ((Elf64_External_RegInfo
*)
10158 mips_regmask_frag
));
10161 /* Set the MIPS ELF flag bits. FIXME: There should probably be some
10162 sort of BFD interface for this. */
10163 if (mips_any_noreorder
)
10164 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_NOREORDER
;
10165 if (mips_pic
!= NO_PIC
)
10166 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_PIC
;
10169 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */
10171 /* These functions should really be defined by the object file format,
10172 since they are related to debugging information. However, this
10173 code has to work for the a.out format, which does not define them,
10174 so we provide simple versions here. These don't actually generate
10175 any debugging information, but they do simple checking and someday
10176 somebody may make them useful. */
10180 struct loc
*loc_next
;
10181 unsigned long loc_fileno
;
10182 unsigned long loc_lineno
;
10183 unsigned long loc_offset
;
10184 unsigned short loc_delta
;
10185 unsigned short loc_count
;
10192 typedef struct proc
10194 struct proc
*proc_next
;
10195 struct symbol
*proc_isym
;
10196 struct symbol
*proc_end
;
10197 unsigned long proc_reg_mask
;
10198 unsigned long proc_reg_offset
;
10199 unsigned long proc_fpreg_mask
;
10200 unsigned long proc_fpreg_offset
;
10201 unsigned long proc_frameoffset
;
10202 unsigned long proc_framereg
;
10203 unsigned long proc_pcreg
;
10205 struct file
*proc_file
;
10210 typedef struct file
10212 struct file
*file_next
;
10213 unsigned long file_fileno
;
10214 struct symbol
*file_symbol
;
10215 struct symbol
*file_end
;
10216 struct proc
*file_proc
;
10221 static struct obstack proc_frags
;
10222 static procS
*proc_lastP
;
10223 static procS
*proc_rootP
;
10224 static int numprocs
;
10229 obstack_begin (&proc_frags
, 0x2000);
10235 /* check for premature end, nesting errors, etc */
10236 if (proc_lastP
&& proc_lastP
->proc_end
== NULL
)
10237 as_warn ("missing `.end' at end of assembly");
10246 if (*input_line_pointer
== '-')
10248 ++input_line_pointer
;
10251 if (!isdigit (*input_line_pointer
))
10252 as_bad ("Expected simple number.");
10253 if (input_line_pointer
[0] == '0')
10255 if (input_line_pointer
[1] == 'x')
10257 input_line_pointer
+= 2;
10258 while (isxdigit (*input_line_pointer
))
10261 val
|= hex_value (*input_line_pointer
++);
10263 return negative
? -val
: val
;
10267 ++input_line_pointer
;
10268 while (isdigit (*input_line_pointer
))
10271 val
|= *input_line_pointer
++ - '0';
10273 return negative
? -val
: val
;
10276 if (!isdigit (*input_line_pointer
))
10278 printf (" *input_line_pointer == '%c' 0x%02x\n",
10279 *input_line_pointer
, *input_line_pointer
);
10280 as_warn ("Invalid number");
10283 while (isdigit (*input_line_pointer
))
10286 val
+= *input_line_pointer
++ - '0';
10288 return negative
? -val
: val
;
10291 /* The .file directive; just like the usual .file directive, but there
10292 is an initial number which is the ECOFF file index. */
10300 line
= get_number ();
10305 /* The .end directive. */
10313 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
10316 demand_empty_rest_of_line ();
10320 if (now_seg
!= text_section
)
10321 as_warn (".end not in text section");
10324 as_warn (".end and no .ent seen yet.");
10330 assert (S_GET_NAME (p
));
10331 if (strcmp (S_GET_NAME (p
), S_GET_NAME (proc_lastP
->proc_isym
)))
10332 as_warn (".end symbol does not match .ent symbol.");
10335 proc_lastP
->proc_end
= (symbolS
*) 1;
10338 /* The .aent and .ent directives. */
10348 symbolP
= get_symbol ();
10349 if (*input_line_pointer
== ',')
10350 input_line_pointer
++;
10351 SKIP_WHITESPACE ();
10352 if (isdigit (*input_line_pointer
) || *input_line_pointer
== '-')
10353 number
= get_number ();
10354 if (now_seg
!= text_section
)
10355 as_warn (".ent or .aent not in text section.");
10357 if (!aent
&& proc_lastP
&& proc_lastP
->proc_end
== NULL
)
10358 as_warn ("missing `.end'");
10362 procP
= (procS
*) obstack_alloc (&proc_frags
, sizeof (*procP
));
10363 procP
->proc_isym
= symbolP
;
10364 procP
->proc_reg_mask
= 0;
10365 procP
->proc_reg_offset
= 0;
10366 procP
->proc_fpreg_mask
= 0;
10367 procP
->proc_fpreg_offset
= 0;
10368 procP
->proc_frameoffset
= 0;
10369 procP
->proc_framereg
= 0;
10370 procP
->proc_pcreg
= 0;
10371 procP
->proc_end
= NULL
;
10372 procP
->proc_next
= NULL
;
10374 proc_lastP
->proc_next
= procP
;
10376 proc_rootP
= procP
;
10377 proc_lastP
= procP
;
10380 demand_empty_rest_of_line ();
10383 /* The .frame directive. */
10396 frame_reg
= tc_get_register (1);
10397 if (*input_line_pointer
== ',')
10398 input_line_pointer
++;
10399 frame_off
= get_absolute_expression ();
10400 if (*input_line_pointer
== ',')
10401 input_line_pointer
++;
10402 pcreg
= tc_get_register (0);
10404 /* bob third eye */
10405 assert (proc_rootP
);
10406 proc_rootP
->proc_framereg
= frame_reg
;
10407 proc_rootP
->proc_frameoffset
= frame_off
;
10408 proc_rootP
->proc_pcreg
= pcreg
;
10409 /* bob macho .frame */
10411 /* We don't have to write out a frame stab for unoptimized code. */
10412 if (!(frame_reg
== FP
&& frame_off
== 0))
10415 as_warn ("No .ent for .frame to use.");
10416 (void) sprintf (str
, "R%d;%d", frame_reg
, frame_off
);
10417 symP
= symbol_new (str
, N_VFP
, 0, frag_now
);
10418 S_SET_TYPE (symP
, N_RMASK
);
10419 S_SET_OTHER (symP
, 0);
10420 S_SET_DESC (symP
, 0);
10421 symP
->sy_forward
= proc_lastP
->proc_isym
;
10422 /* bob perhaps I should have used pseudo set */
10424 demand_empty_rest_of_line ();
10428 /* The .fmask and .mask directives. */
10435 char str
[100], *strP
;
10441 mask
= get_number ();
10442 if (*input_line_pointer
== ',')
10443 input_line_pointer
++;
10444 off
= get_absolute_expression ();
10446 /* bob only for coff */
10447 assert (proc_rootP
);
10448 if (reg_type
== 'F')
10450 proc_rootP
->proc_fpreg_mask
= mask
;
10451 proc_rootP
->proc_fpreg_offset
= off
;
10455 proc_rootP
->proc_reg_mask
= mask
;
10456 proc_rootP
->proc_reg_offset
= off
;
10459 /* bob macho .mask + .fmask */
10461 /* We don't have to write out a mask stab if no saved regs. */
10465 as_warn ("No .ent for .mask to use.");
10467 for (i
= 0; i
< 32; i
++)
10471 sprintf (strP
, "%c%d,", reg_type
, i
);
10472 strP
+= strlen (strP
);
10476 sprintf (strP
, ";%d,", off
);
10477 symP
= symbol_new (str
, N_RMASK
, 0, frag_now
);
10478 S_SET_TYPE (symP
, N_RMASK
);
10479 S_SET_OTHER (symP
, 0);
10480 S_SET_DESC (symP
, 0);
10481 symP
->sy_forward
= proc_lastP
->proc_isym
;
10482 /* bob perhaps I should have used pseudo set */
10487 /* The .loc directive. */
10498 assert (now_seg
== text_section
);
10500 lineno
= get_number ();
10501 addroff
= frag_now_fix ();
10503 symbolP
= symbol_new ("", N_SLINE
, addroff
, frag_now
);
10504 S_SET_TYPE (symbolP
, N_SLINE
);
10505 S_SET_OTHER (symbolP
, 0);
10506 S_SET_DESC (symbolP
, lineno
);
10507 symbolP
->sy_segment
= now_seg
;