1 /* tc-mmix.c -- Assembler for Don Knuth's MMIX.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 51 Franklin Street - Fifth Floor,
19 Boston, MA 02110-1301, USA. */
21 /* Knuth's assembler mmixal does not provide a relocatable format; mmo is
22 to be considered a final link-format. In the final link, we make mmo,
23 but for relocatable files, we use ELF.
25 One goal is to provide a superset of what mmixal does, including
26 compatible syntax, but the main purpose is to serve GCC. */
33 #include "opcode/mmix.h"
34 #include "safe-ctype.h"
35 #include "dwarf2dbg.h"
38 /* Something to describe what we need to do with a fixup before output,
39 for example assert something of what it became or make a relocation. */
41 enum mmix_fixup_action
45 mmix_fixup_register_or_adjust_for_byte
48 static int get_spec_regno (char *);
49 static int get_operands (int, char *, expressionS
*);
50 static int get_putget_operands (struct mmix_opcode
*, char *, expressionS
*);
51 static void s_prefix (int);
52 static void s_greg (int);
53 static void s_loc (int);
54 static void s_bspec (int);
55 static void s_espec (int);
56 static void mmix_s_local (int);
57 static void mmix_greg_internal (char *);
58 static void mmix_set_geta_branch_offset (char *, offsetT
);
59 static void mmix_set_jmp_offset (char *, offsetT
);
60 static void mmix_fill_nops (char *, int);
61 static int cmp_greg_symbol_fixes (const void *, const void *);
62 static int cmp_greg_val_greg_symbol_fixes (const void *, const void *);
63 static void mmix_handle_rest_of_empty_line (void);
64 static void mmix_discard_rest_of_line (void);
65 static void mmix_byte (void);
66 static void mmix_cons (int);
68 /* Continue the tradition of symbols.c; use control characters to enforce
69 magic. These are used when replacing e.g. 8F and 8B so we can handle
70 such labels correctly with the common parser hooks. */
71 #define MAGIC_FB_BACKWARD_CHAR '\003'
72 #define MAGIC_FB_FORWARD_CHAR '\004'
74 /* Copy the location of a frag to a fix. */
75 #define COPY_FR_WHERE_TO_FX(FRAG, FIX) \
78 (FIX)->fx_file = (FRAG)->fr_file; \
79 (FIX)->fx_line = (FRAG)->fr_line; \
83 const char *md_shortopts
= "x";
84 static int current_fb_label
= -1;
85 static char *pending_label
= NULL
;
87 static bfd_vma lowest_text_loc
= (bfd_vma
) -1;
88 static int text_has_contents
= 0;
90 /* The alignment of the previous instruction, and a boolean for whether we
91 want to avoid aligning the next WYDE, TETRA, OCTA or insn. */
92 static int last_alignment
= 0;
93 static int want_unaligned
= 0;
95 static bfd_vma lowest_data_loc
= (bfd_vma
) -1;
96 static int data_has_contents
= 0;
98 /* The fragS of the instruction being assembled. Only valid from within
100 fragS
*mmix_opcode_frag
= NULL
;
102 /* Raw GREGs as appearing in input. These may be fewer than the number
104 static int n_of_raw_gregs
= 0;
109 } mmix_raw_gregs
[MAX_GREGS
];
111 static struct loc_assert_s
116 struct loc_assert_s
*next
;
117 } *loc_asserts
= NULL
;
119 /* Fixups for all unique GREG registers. We store the fixups here in
120 md_convert_frag, then we use the array to convert
121 BFD_RELOC_MMIX_BASE_PLUS_OFFSET fixups in tc_gen_reloc. The index is
122 just a running number and is not supposed to be correlated to a
124 static fixS
*mmix_gregs
[MAX_GREGS
];
125 static int n_of_cooked_gregs
= 0;
127 /* Pointing to the register section we use for output. */
128 static asection
*real_reg_section
;
130 /* For each symbol; unknown or section symbol, we keep a list of GREG
131 definitions sorted on increasing offset. It seems no use keeping count
132 to allocate less room than the maximum number of gregs when we've found
133 one for a section or symbol. */
134 struct mmix_symbol_gregs
137 struct mmix_symbol_greg_fixes
141 /* A signed type, since we may have GREGs pointing slightly before the
142 contents of a section. */
144 } greg_fixes
[MAX_GREGS
];
147 /* Should read insert a colon on something that starts in column 0 on
149 static int label_without_colon_this_line
= 1;
151 /* Should we automatically expand instructions into multiple insns in
152 order to generate working code? */
153 static int expand_op
= 1;
155 /* Should we warn when expanding operands? FIXME: test-cases for when -x
157 static int warn_on_expansion
= 1;
159 /* Should we merge non-zero GREG register definitions? */
160 static int merge_gregs
= 1;
162 /* Should we pass on undefined BFD_RELOC_MMIX_BASE_PLUS_OFFSET relocs
163 (missing suitable GREG definitions) to the linker? */
164 static int allocate_undefined_gregs_in_linker
= 0;
166 /* Should we emit built-in symbols? */
167 static int predefined_syms
= 1;
169 /* Should we allow anything but the listed special register name
170 (e.g. equated symbols)? */
171 static int equated_spec_regs
= 1;
173 /* Do we require standard GNU syntax? */
174 int mmix_gnu_syntax
= 0;
176 /* Do we globalize all symbols? */
177 int mmix_globalize_symbols
= 0;
179 /* When expanding insns, do we want to expand PUSHJ as a call to a stub
180 (or else as a series of insns)? */
183 /* Do we know that the next semicolon is at the end of the operands field
184 (in mmixal mode; constant 1 in GNU mode)? */
185 int mmix_next_semicolon_is_eoln
= 1;
187 /* Do we have a BSPEC in progress? */
188 static int doing_bspec
= 0;
189 static const char *bspec_file
;
190 static unsigned int bspec_line
;
192 struct option md_longopts
[] =
194 #define OPTION_RELAX (OPTION_MD_BASE)
195 #define OPTION_NOEXPAND (OPTION_RELAX + 1)
196 #define OPTION_NOMERGEGREG (OPTION_NOEXPAND + 1)
197 #define OPTION_NOSYMS (OPTION_NOMERGEGREG + 1)
198 #define OPTION_GNU_SYNTAX (OPTION_NOSYMS + 1)
199 #define OPTION_GLOBALIZE_SYMBOLS (OPTION_GNU_SYNTAX + 1)
200 #define OPTION_FIXED_SPEC_REGS (OPTION_GLOBALIZE_SYMBOLS + 1)
201 #define OPTION_LINKER_ALLOCATED_GREGS (OPTION_FIXED_SPEC_REGS + 1)
202 #define OPTION_NOPUSHJSTUBS (OPTION_LINKER_ALLOCATED_GREGS + 1)
203 {"linkrelax", no_argument
, NULL
, OPTION_RELAX
},
204 {"no-expand", no_argument
, NULL
, OPTION_NOEXPAND
},
205 {"no-merge-gregs", no_argument
, NULL
, OPTION_NOMERGEGREG
},
206 {"no-predefined-syms", no_argument
, NULL
, OPTION_NOSYMS
},
207 {"gnu-syntax", no_argument
, NULL
, OPTION_GNU_SYNTAX
},
208 {"globalize-symbols", no_argument
, NULL
, OPTION_GLOBALIZE_SYMBOLS
},
209 {"fixed-special-register-names", no_argument
, NULL
,
210 OPTION_FIXED_SPEC_REGS
},
211 {"linker-allocated-gregs", no_argument
, NULL
,
212 OPTION_LINKER_ALLOCATED_GREGS
},
213 {"no-pushj-stubs", no_argument
, NULL
, OPTION_NOPUSHJSTUBS
},
214 {"no-stubs", no_argument
, NULL
, OPTION_NOPUSHJSTUBS
},
215 {NULL
, no_argument
, NULL
, 0}
218 size_t md_longopts_size
= sizeof (md_longopts
);
220 static struct hash_control
*mmix_opcode_hash
;
222 /* We use these when implementing the PREFIX pseudo. */
223 char *mmix_current_prefix
;
224 struct obstack mmix_sym_obstack
;
227 /* For MMIX, we encode the relax_substateT:s (in e.g. fr_substate) as one
228 bit length, and the relax-type shifted on top of that. There seems to
229 be no point in making the relaxation more fine-grained; the linker does
230 that better and we might interfere by changing non-optimal relaxations
231 into other insns that cannot be relaxed as easily.
233 Groups for MMIX relaxing:
236 extra length: zero or three insns.
239 extra length: zero or five insns.
242 extra length: zero or four insns.
243 Special handling to deal with transition to PUSHJSTUB.
246 extra length: zero or four insns.
249 special handling, allocates a named global register unless another
250 is within reach for all uses.
253 special handling (mostly) for external references; assumes the
254 linker will generate a stub if target is no longer than 256k from
255 the end of the section plus max size of previous stubs. Zero or
258 #define STATE_GETA (1)
259 #define STATE_BCC (2)
260 #define STATE_PUSHJ (3)
261 #define STATE_JMP (4)
262 #define STATE_GREG (5)
263 #define STATE_PUSHJSTUB (6)
265 /* No fine-grainedness here. */
266 #define STATE_LENGTH_MASK (1)
268 #define STATE_ZERO (0)
269 #define STATE_MAX (1)
271 /* More descriptive name for convenience. */
272 /* FIXME: We should start on something different, not MAX. */
273 #define STATE_UNDF STATE_MAX
275 /* FIXME: For GREG, we must have other definitions; UNDF == MAX isn't
276 appropriate; we need it the other way round. This value together with
277 fragP->tc_frag_data shows what state the frag is in: tc_frag_data
278 non-NULL means 0, NULL means 8 bytes. */
279 #define STATE_GREG_UNDF ENCODE_RELAX (STATE_GREG, STATE_ZERO)
280 #define STATE_GREG_DEF ENCODE_RELAX (STATE_GREG, STATE_MAX)
282 /* These displacements are relative to the address following the opcode
283 word of the instruction. The catch-all states have zero for "reach"
284 and "next" entries. */
286 #define GETA_0F (65536 * 4 - 8)
287 #define GETA_0B (-65536 * 4 - 4)
289 #define GETA_MAX_LEN 4 * 4
293 #define BCC_0F GETA_0F
294 #define BCC_0B GETA_0B
296 #define BCC_MAX_LEN 6 * 4
297 #define BCC_5F GETA_3F
298 #define BCC_5B GETA_3B
300 #define PUSHJ_0F GETA_0F
301 #define PUSHJ_0B GETA_0B
303 #define PUSHJ_MAX_LEN 5 * 4
304 #define PUSHJ_4F GETA_3F
305 #define PUSHJ_4B GETA_3B
307 /* We'll very rarely have sections longer than LONG_MAX, but we'll make a
308 feeble attempt at getting 64-bit values. */
309 #define PUSHJSTUB_MAX ((offsetT) (((addressT) -1) >> 1))
310 #define PUSHJSTUB_MIN (-PUSHJSTUB_MAX - 1)
312 #define JMP_0F (65536 * 256 * 4 - 8)
313 #define JMP_0B (-65536 * 256 * 4 - 4)
315 #define JMP_MAX_LEN 5 * 4
319 #define RELAX_ENCODE_SHIFT 1
320 #define ENCODE_RELAX(what, length) (((what) << RELAX_ENCODE_SHIFT) + (length))
322 const relax_typeS mmix_relax_table
[] =
324 /* Error sentinel (0, 0). */
331 {GETA_0F
, GETA_0B
, 0, ENCODE_RELAX (STATE_GETA
, STATE_MAX
)},
335 GETA_MAX_LEN
- 4, 0},
338 {BCC_0F
, BCC_0B
, 0, ENCODE_RELAX (STATE_BCC
, STATE_MAX
)},
344 /* PUSHJ (3, 0). Next state is actually PUSHJSTUB (6, 0). */
345 {PUSHJ_0F
, PUSHJ_0B
, 0, ENCODE_RELAX (STATE_PUSHJSTUB
, STATE_ZERO
)},
349 PUSHJ_MAX_LEN
- 4, 0},
352 {JMP_0F
, JMP_0B
, 0, ENCODE_RELAX (STATE_JMP
, STATE_MAX
)},
358 /* GREG (5, 0), (5, 1), though the table entry isn't used. */
359 {0, 0, 0, 0}, {0, 0, 0, 0},
361 /* PUSHJSTUB (6, 0). PUSHJ (3, 0) uses the range, so we set it to infinite. */
362 {PUSHJSTUB_MAX
, PUSHJSTUB_MIN
,
363 0, ENCODE_RELAX (STATE_PUSHJ
, STATE_MAX
)},
364 /* PUSHJSTUB (6, 1) isn't used. */
365 {0, 0, PUSHJ_MAX_LEN
, 0}
368 const pseudo_typeS md_pseudo_table
[] =
370 /* Support " .greg sym,expr" syntax. */
373 /* Support " .bspec expr" syntax. */
374 {"bspec", s_bspec
, 1},
376 /* Support " .espec" syntax. */
377 {"espec", s_espec
, 1},
379 /* Support " .local $45" syntax. */
380 {"local", mmix_s_local
, 1},
385 const char mmix_comment_chars
[] = "%!";
387 /* A ':' is a valid symbol character in mmixal. It's the prefix
388 delimiter, but other than that, it works like a symbol character,
389 except that we strip one off at the beginning of symbols. An '@' is a
390 symbol by itself (for the current location); space around it must not
392 const char mmix_symbol_chars
[] = ":@";
394 const char line_comment_chars
[] = "*#";
396 const char line_separator_chars
[] = ";";
398 const char EXP_CHARS
[] = "eE";
400 const char FLT_CHARS
[] = "rf";
403 /* Fill in the offset-related part of GETA or Bcc. */
406 mmix_set_geta_branch_offset (char *opcodep
, offsetT value
)
415 md_number_to_chars (opcodep
+ 2, value
, 2);
418 /* Fill in the offset-related part of JMP. */
421 mmix_set_jmp_offset (char *opcodep
, offsetT value
)
425 value
+= 65536 * 256 * 4;
430 md_number_to_chars (opcodep
+ 1, value
, 3);
433 /* Fill in NOP:s for the expanded part of GETA/JMP/Bcc/PUSHJ. */
436 mmix_fill_nops (char *opcodep
, int n
)
440 for (i
= 0; i
< n
; i
++)
441 md_number_to_chars (opcodep
+ i
* 4, SWYM_INSN_BYTE
<< 24, 4);
444 /* See macro md_parse_name in tc-mmix.h. */
447 mmix_current_location (void (*fn
) (expressionS
*), expressionS
*exp
)
454 /* Get up to three operands, filling them into the exp array.
455 General idea and code stolen from the tic80 port. */
458 get_operands (int max_operands
, char *s
, expressionS
*exp
)
464 while (nextchar
== ',')
466 /* Skip leading whitespace */
467 while (*p
== ' ' || *p
== '\t')
470 /* Check to see if we have any operands left to parse */
471 if (*p
== 0 || *p
== '\n' || *p
== '\r')
475 else if (numexp
== max_operands
)
477 /* This seems more sane than saying "too many operands". We'll
478 get here only if the trailing trash starts with a comma. */
479 as_bad (_("invalid operands"));
480 mmix_discard_rest_of_line ();
484 /* Begin operand parsing at the current scan point. */
486 input_line_pointer
= p
;
487 expression (&exp
[numexp
]);
489 if (exp
[numexp
].X_op
== O_illegal
)
491 as_bad (_("invalid operands"));
493 else if (exp
[numexp
].X_op
== O_absent
)
495 as_bad (_("missing operand"));
499 p
= input_line_pointer
;
501 /* Skip leading whitespace */
502 while (*p
== ' ' || *p
== '\t')
507 /* If we allow "naked" comments, ignore the rest of the line. */
510 mmix_handle_rest_of_empty_line ();
511 input_line_pointer
--;
514 /* Mark the end of the valid operands with an illegal expression. */
515 exp
[numexp
].X_op
= O_illegal
;
520 /* Get the value of a special register, or -1 if the name does not match
521 one. NAME is a null-terminated string. */
524 get_spec_regno (char *name
)
534 /* Well, it's a short array and we'll most often just match the first
536 for (i
= 0; mmix_spec_regs
[i
].name
!= NULL
; i
++)
537 if (strcmp (name
, mmix_spec_regs
[i
].name
) == 0)
538 return mmix_spec_regs
[i
].number
;
543 /* For GET and PUT, parse the register names "manually", so we don't use
546 get_putget_operands (struct mmix_opcode
*insn
, char *operands
,
549 expressionS
*expp_reg
;
550 expressionS
*expp_sreg
;
552 char *sregend
= operands
;
557 /* Skip leading whitespace */
558 while (*p
== ' ' || *p
== '\t')
561 input_line_pointer
= p
;
563 /* Initialize both possible operands to error state, in case we never
565 exp
[0].X_op
= O_illegal
;
566 exp
[1].X_op
= O_illegal
;
568 if (insn
->operands
== mmix_operands_get
)
573 expression (expp_reg
);
575 p
= input_line_pointer
;
577 /* Skip whitespace */
578 while (*p
== ' ' || *p
== '\t')
585 /* Skip whitespace */
586 while (*p
== ' ' || *p
== '\t')
589 input_line_pointer
= sregp
;
590 c
= get_symbol_name (&sregp
);
591 sregend
= input_line_pointer
;
593 ++ input_line_pointer
;
601 c
= get_symbol_name (&sregp
);
602 sregend
= input_line_pointer
;
603 restore_line_pointer (c
);
604 p
= input_line_pointer
;
606 /* Skip whitespace */
607 while (*p
== ' ' || *p
== '\t')
614 /* Skip whitespace */
615 while (*p
== ' ' || *p
== '\t')
618 input_line_pointer
= p
;
619 expression (expp_reg
);
624 regno
= get_spec_regno (sregp
);
627 /* Let the caller issue errors; we've made sure the operands are
629 if (expp_reg
->X_op
!= O_illegal
630 && expp_reg
->X_op
!= O_absent
633 expp_sreg
->X_op
= O_register
;
634 expp_sreg
->X_add_number
= regno
+ 256;
640 /* Handle MMIX-specific option. */
643 md_parse_option (int c
, const char *arg ATTRIBUTE_UNUSED
)
648 warn_on_expansion
= 0;
649 allocate_undefined_gregs_in_linker
= 1;
656 case OPTION_NOEXPAND
:
660 case OPTION_NOMERGEGREG
:
666 equated_spec_regs
= 0;
669 case OPTION_GNU_SYNTAX
:
671 label_without_colon_this_line
= 0;
674 case OPTION_GLOBALIZE_SYMBOLS
:
675 mmix_globalize_symbols
= 1;
678 case OPTION_FIXED_SPEC_REGS
:
679 equated_spec_regs
= 0;
682 case OPTION_LINKER_ALLOCATED_GREGS
:
683 allocate_undefined_gregs_in_linker
= 1;
686 case OPTION_NOPUSHJSTUBS
:
697 /* Display MMIX-specific help text. */
700 md_show_usage (FILE * stream
)
702 fprintf (stream
, _(" MMIX-specific command line options:\n"));
703 fprintf (stream
, _("\
704 -fixed-special-register-names\n\
705 Allow only the original special register names.\n"));
706 fprintf (stream
, _("\
707 -globalize-symbols Make all symbols global.\n"));
708 fprintf (stream
, _("\
709 -gnu-syntax Turn off mmixal syntax compatibility.\n"));
710 fprintf (stream
, _("\
711 -relax Create linker relaxable code.\n"));
712 fprintf (stream
, _("\
713 -no-predefined-syms Do not provide mmixal built-in constants.\n\
714 Implies -fixed-special-register-names.\n"));
715 fprintf (stream
, _("\
716 -no-expand Do not expand GETA, branches, PUSHJ or JUMP\n\
717 into multiple instructions.\n"));
718 fprintf (stream
, _("\
719 -no-merge-gregs Do not merge GREG definitions with nearby values.\n"));
720 fprintf (stream
, _("\
721 -linker-allocated-gregs If there's no suitable GREG definition for the\
722 operands of an instruction, let the linker resolve.\n"));
723 fprintf (stream
, _("\
724 -x Do not warn when an operand to GETA, a branch,\n\
725 PUSHJ or JUMP is not known to be within range.\n\
726 The linker will catch any errors. Implies\n\
727 -linker-allocated-gregs."));
730 /* Step to end of line, but don't step over the end of the line. */
733 mmix_discard_rest_of_line (void)
735 while (*input_line_pointer
736 && (! is_end_of_line
[(unsigned char) *input_line_pointer
]
737 || TC_EOL_IN_INSN (input_line_pointer
)))
738 input_line_pointer
++;
741 /* Act as demand_empty_rest_of_line if we're in strict GNU syntax mode,
742 otherwise just ignore the rest of the line (and skip the end-of-line
746 mmix_handle_rest_of_empty_line (void)
749 demand_empty_rest_of_line ();
752 mmix_discard_rest_of_line ();
753 input_line_pointer
++;
757 /* Initialize GAS MMIX specifics. */
763 const struct mmix_opcode
*opcode
;
765 /* We assume nobody will use this, so don't allocate any room. */
766 obstack_begin (&mmix_sym_obstack
, 0);
768 /* This will break the day the "lex" thingy changes. For now, it's the
769 only way to make ':' part of a name, and a name beginner. */
770 lex_type
[':'] = (LEX_NAME
| LEX_BEGIN_NAME
);
772 mmix_opcode_hash
= hash_new ();
775 = bfd_make_section_old_way (stdoutput
, MMIX_REG_SECTION_NAME
);
777 for (opcode
= mmix_opcodes
; opcode
->name
; opcode
++)
778 hash_insert (mmix_opcode_hash
, opcode
->name
, (char *) opcode
);
780 /* We always insert the ordinary registers 0..255 as registers. */
781 for (i
= 0; i
< 256; i
++)
785 /* Alternatively, we could diddle with '$' and the following number,
786 but keeping the registers as symbols helps keep parsing simple. */
787 sprintf (buf
, "$%d", i
);
788 symbol_table_insert (symbol_new (buf
, reg_section
, i
,
789 &zero_address_frag
));
792 /* Insert mmixal built-in names if allowed. */
795 for (i
= 0; mmix_spec_regs
[i
].name
!= NULL
; i
++)
796 symbol_table_insert (symbol_new (mmix_spec_regs
[i
].name
,
798 mmix_spec_regs
[i
].number
+ 256,
799 &zero_address_frag
));
801 /* FIXME: Perhaps these should be recognized as specials; as field
802 names for those instructions. */
803 symbol_table_insert (symbol_new ("ROUND_CURRENT", reg_section
, 512,
804 &zero_address_frag
));
805 symbol_table_insert (symbol_new ("ROUND_OFF", reg_section
, 512 + 1,
806 &zero_address_frag
));
807 symbol_table_insert (symbol_new ("ROUND_UP", reg_section
, 512 + 2,
808 &zero_address_frag
));
809 symbol_table_insert (symbol_new ("ROUND_DOWN", reg_section
, 512 + 3,
810 &zero_address_frag
));
811 symbol_table_insert (symbol_new ("ROUND_NEAR", reg_section
, 512 + 4,
812 &zero_address_frag
));
816 /* Assemble one insn in STR. */
819 md_assemble (char *str
)
821 char *operands
= str
;
822 char modified_char
= 0;
823 struct mmix_opcode
*instruction
;
824 fragS
*opc_fragP
= NULL
;
825 int max_operands
= 3;
827 /* Note that the struct frag member fr_literal in frags.h is char[], so
828 I have to make this a plain char *. */
829 /* unsigned */ char *opcodep
= NULL
;
834 /* Move to end of opcode. */
836 is_part_of_name (*operands
);
840 if (ISSPACE (*operands
))
842 modified_char
= *operands
;
846 instruction
= (struct mmix_opcode
*) hash_find (mmix_opcode_hash
, str
);
847 if (instruction
== NULL
)
849 as_bad (_("unknown opcode: `%s'"), str
);
851 /* Avoid "unhandled label" errors. */
852 pending_label
= NULL
;
856 /* Put back the character after the opcode. */
857 if (modified_char
!= 0)
858 operands
[-1] = modified_char
;
860 input_line_pointer
= operands
;
862 /* Is this a mmixal pseudodirective? */
863 if (instruction
->type
== mmix_type_pseudo
)
865 /* For mmixal compatibility, a label for an instruction (and
866 emitting pseudo) refers to the _aligned_ address. We emit the
867 label here for the pseudos that don't handle it themselves. When
868 having an fb-label, emit it here, and increment the counter after
870 switch (instruction
->operands
)
872 case mmix_operands_loc
:
873 case mmix_operands_byte
:
874 case mmix_operands_prefix
:
875 case mmix_operands_local
:
876 case mmix_operands_bspec
:
877 case mmix_operands_espec
:
878 if (current_fb_label
>= 0)
879 colon (fb_label_name (current_fb_label
, 1));
880 else if (pending_label
!= NULL
)
882 colon (pending_label
);
883 pending_label
= NULL
;
891 /* Some of the pseudos emit contents, others don't. Set a
892 contents-emitted flag when we emit something into .text */
893 switch (instruction
->operands
)
895 case mmix_operands_loc
:
900 case mmix_operands_byte
:
905 case mmix_operands_wyde
:
910 case mmix_operands_tetra
:
915 case mmix_operands_octa
:
920 case mmix_operands_prefix
:
925 case mmix_operands_local
:
930 case mmix_operands_bspec
:
935 case mmix_operands_espec
:
941 BAD_CASE (instruction
->operands
);
944 /* These are all working like the pseudo functions in read.c:s_...,
945 in that they step over the end-of-line marker at the end of the
946 line. We don't want that here. */
947 input_line_pointer
--;
949 /* Step up the fb-label counter if there was a definition on this
951 if (current_fb_label
>= 0)
953 fb_label_instance_inc (current_fb_label
);
954 current_fb_label
= -1;
957 /* Reset any don't-align-next-datum request, unless this was a LOC
959 if (instruction
->operands
!= mmix_operands_loc
)
965 /* Not a pseudo; we *will* emit contents. */
966 if (now_seg
== data_section
)
968 if (lowest_data_loc
!= (bfd_vma
) -1 && (lowest_data_loc
& 3) != 0)
970 if (data_has_contents
)
971 as_bad (_("specified location wasn't TETRA-aligned"));
972 else if (want_unaligned
)
973 as_bad (_("unaligned data at an absolute location is not supported"));
975 lowest_data_loc
&= ~(bfd_vma
) 3;
976 lowest_data_loc
+= 4;
979 data_has_contents
= 1;
981 else if (now_seg
== text_section
)
983 if (lowest_text_loc
!= (bfd_vma
) -1 && (lowest_text_loc
& 3) != 0)
985 if (text_has_contents
)
986 as_bad (_("specified location wasn't TETRA-aligned"));
987 else if (want_unaligned
)
988 as_bad (_("unaligned data at an absolute location is not supported"));
990 lowest_text_loc
&= ~(bfd_vma
) 3;
991 lowest_text_loc
+= 4;
994 text_has_contents
= 1;
997 /* After a sequence of BYTEs or WYDEs, we need to get to instruction
998 alignment. For other pseudos, a ".p2align 2" is supposed to be
999 inserted by the user. */
1000 if (last_alignment
< 2 && ! want_unaligned
)
1002 frag_align (2, 0, 0);
1003 record_alignment (now_seg
, 2);
1007 /* Reset any don't-align-next-datum request. */
1010 /* For mmixal compatibility, a label for an instruction (and emitting
1011 pseudo) refers to the _aligned_ address. So we have to emit the
1013 if (pending_label
!= NULL
)
1015 colon (pending_label
);
1016 pending_label
= NULL
;
1019 /* We assume that mmix_opcodes keeps having unique mnemonics for each
1020 opcode, so we don't have to iterate over more than one opcode; if the
1021 syntax does not match, then there's a syntax error. */
1023 /* Operands have little or no context and are all comma-separated; it is
1024 easier to parse each expression first. */
1025 switch (instruction
->operands
)
1027 case mmix_operands_reg_yz
:
1028 case mmix_operands_pop
:
1029 case mmix_operands_regaddr
:
1030 case mmix_operands_pushj
:
1031 case mmix_operands_get
:
1032 case mmix_operands_put
:
1033 case mmix_operands_set
:
1034 case mmix_operands_save
:
1035 case mmix_operands_unsave
:
1039 case mmix_operands_sync
:
1040 case mmix_operands_jmp
:
1041 case mmix_operands_resume
:
1045 /* The original 3 is fine for the rest. */
1050 /* If this is GET or PUT, and we don't do allow those names to be
1051 equated, we need to parse the names ourselves, so we don't pick up a
1052 user label instead of the special register. */
1053 if (! equated_spec_regs
1054 && (instruction
->operands
== mmix_operands_get
1055 || instruction
->operands
== mmix_operands_put
))
1056 n_operands
= get_putget_operands (instruction
, operands
, exp
);
1058 n_operands
= get_operands (max_operands
, operands
, exp
);
1060 /* If there's a fb-label on the current line, set that label. This must
1061 be done *after* evaluating expressions of operands, since neither a
1062 "1B" nor a "1F" refers to "1H" on the same line. */
1063 if (current_fb_label
>= 0)
1065 fb_label_instance_inc (current_fb_label
);
1066 colon (fb_label_name (current_fb_label
, 0));
1067 current_fb_label
= -1;
1070 /* We also assume that the length of the instruction is at least 4, the
1071 size of an unexpanded instruction. We need a self-contained frag
1072 since we want the relocation to point to the instruction, not the
1075 opcodep
= frag_more (4);
1076 mmix_opcode_frag
= opc_fragP
= frag_now
;
1077 frag_now
->fr_opcode
= opcodep
;
1079 /* Mark start of insn for DWARF2 debug features. */
1080 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1081 dwarf2_emit_insn (4);
1083 md_number_to_chars (opcodep
, instruction
->match
, 4);
1085 switch (instruction
->operands
)
1087 case mmix_operands_jmp
:
1088 if (n_operands
== 0 && ! mmix_gnu_syntax
)
1089 /* Zeros are in place - nothing needs to be done when we have no
1093 /* Add a frag for a JMP relaxation; we need room for max four
1094 extra instructions. We don't do any work around here to check if
1095 we can determine the offset right away. */
1096 if (n_operands
!= 1 || exp
[0].X_op
== O_register
)
1098 as_bad (_("invalid operand to opcode %s: `%s'"),
1099 instruction
->name
, operands
);
1104 frag_var (rs_machine_dependent
, 4 * 4, 0,
1105 ENCODE_RELAX (STATE_JMP
, STATE_UNDF
),
1106 exp
[0].X_add_symbol
,
1107 exp
[0].X_add_number
,
1110 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
, 4,
1111 exp
+ 0, 1, BFD_RELOC_MMIX_ADDR27
);
1114 case mmix_operands_pushj
:
1115 /* We take care of PUSHJ in full here. */
1117 || ((exp
[0].X_op
== O_constant
|| exp
[0].X_op
== O_register
)
1118 && (exp
[0].X_add_number
> 255 || exp
[0].X_add_number
< 0)))
1120 as_bad (_("invalid operands to opcode %s: `%s'"),
1121 instruction
->name
, operands
);
1125 if (exp
[0].X_op
== O_register
|| exp
[0].X_op
== O_constant
)
1126 opcodep
[1] = exp
[0].X_add_number
;
1128 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1129 1, exp
+ 0, 0, BFD_RELOC_MMIX_REG_OR_BYTE
);
1132 frag_var (rs_machine_dependent
, PUSHJ_MAX_LEN
- 4, 0,
1133 ENCODE_RELAX (STATE_PUSHJ
, STATE_UNDF
),
1134 exp
[1].X_add_symbol
,
1135 exp
[1].X_add_number
,
1138 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
, 4,
1139 exp
+ 1, 1, BFD_RELOC_MMIX_ADDR19
);
1142 case mmix_operands_regaddr
:
1143 /* GETA/branch: Add a frag for relaxation. We don't do any work
1144 around here to check if we can determine the offset right away. */
1145 if (n_operands
!= 2 || exp
[1].X_op
== O_register
)
1147 as_bad (_("invalid operands to opcode %s: `%s'"),
1148 instruction
->name
, operands
);
1153 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
, 4,
1154 exp
+ 1, 1, BFD_RELOC_MMIX_ADDR19
);
1155 else if (instruction
->type
== mmix_type_condbranch
)
1156 frag_var (rs_machine_dependent
, BCC_MAX_LEN
- 4, 0,
1157 ENCODE_RELAX (STATE_BCC
, STATE_UNDF
),
1158 exp
[1].X_add_symbol
,
1159 exp
[1].X_add_number
,
1162 frag_var (rs_machine_dependent
, GETA_MAX_LEN
- 4, 0,
1163 ENCODE_RELAX (STATE_GETA
, STATE_UNDF
),
1164 exp
[1].X_add_symbol
,
1165 exp
[1].X_add_number
,
1173 switch (instruction
->operands
)
1175 case mmix_operands_regs
:
1176 /* We check the number of operands here, since we're in a
1177 FALLTHROUGH sequence in the next switch. */
1178 if (n_operands
!= 3 || exp
[2].X_op
== O_constant
)
1180 as_bad (_("invalid operands to opcode %s: `%s'"),
1181 instruction
->name
, operands
);
1185 case mmix_operands_regs_z
:
1186 if (n_operands
!= 3)
1188 as_bad (_("invalid operands to opcode %s: `%s'"),
1189 instruction
->name
, operands
);
1193 case mmix_operands_reg_yz
:
1194 case mmix_operands_roundregs_z
:
1195 case mmix_operands_roundregs
:
1196 case mmix_operands_regs_z_opt
:
1197 case mmix_operands_neg
:
1198 case mmix_operands_regaddr
:
1199 case mmix_operands_get
:
1200 case mmix_operands_set
:
1201 case mmix_operands_save
:
1203 || (exp
[0].X_op
== O_register
&& exp
[0].X_add_number
> 255))
1205 as_bad (_("invalid operands to opcode %s: `%s'"),
1206 instruction
->name
, operands
);
1210 if (exp
[0].X_op
== O_register
)
1211 opcodep
[1] = exp
[0].X_add_number
;
1213 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1214 1, exp
+ 0, 0, BFD_RELOC_MMIX_REG
);
1221 /* A corresponding once-over for those who take an 8-bit constant as
1222 their first operand. */
1223 switch (instruction
->operands
)
1225 case mmix_operands_pushgo
:
1226 /* PUSHGO: X is a constant, but can be expressed as a register.
1227 We handle X here and use the common machinery of T,X,3,$ for
1228 the rest of the operands. */
1230 || ((exp
[0].X_op
== O_constant
|| exp
[0].X_op
== O_register
)
1231 && (exp
[0].X_add_number
> 255 || exp
[0].X_add_number
< 0)))
1233 as_bad (_("invalid operands to opcode %s: `%s'"),
1234 instruction
->name
, operands
);
1237 else if (exp
[0].X_op
== O_constant
|| exp
[0].X_op
== O_register
)
1238 opcodep
[1] = exp
[0].X_add_number
;
1240 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1241 1, exp
+ 0, 0, BFD_RELOC_MMIX_REG_OR_BYTE
);
1244 case mmix_operands_pop
:
1245 if ((n_operands
== 0 || n_operands
== 1) && ! mmix_gnu_syntax
)
1248 case mmix_operands_x_regs_z
:
1250 || (exp
[0].X_op
== O_constant
1251 && (exp
[0].X_add_number
> 255
1252 || exp
[0].X_add_number
< 0)))
1254 as_bad (_("invalid operands to opcode %s: `%s'"),
1255 instruction
->name
, operands
);
1259 if (exp
[0].X_op
== O_constant
)
1260 opcodep
[1] = exp
[0].X_add_number
;
1262 /* FIXME: This doesn't bring us unsignedness checking. */
1263 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1264 1, exp
+ 0, 0, BFD_RELOC_8
);
1269 /* Handle the rest. */
1270 switch (instruction
->operands
)
1272 case mmix_operands_set
:
1273 /* SET: Either two registers, "$X,$Y", with Z field as zero, or
1274 "$X,YZ", meaning change the opcode to SETL. */
1276 || (exp
[1].X_op
== O_constant
1277 && (exp
[1].X_add_number
> 0xffff || exp
[1].X_add_number
< 0)))
1279 as_bad (_("invalid operands to opcode %s: `%s'"),
1280 instruction
->name
, operands
);
1284 if (exp
[1].X_op
== O_constant
)
1286 /* There's an ambiguity with "SET $0,Y" when Y isn't defined
1287 yet. To keep things simple, we assume that Y is then a
1288 register, and only change the opcode if Y is defined at this
1291 There's no compatibility problem with mmixal, since it emits
1292 errors if the field is not defined at this point. */
1293 md_number_to_chars (opcodep
, SETL_INSN_BYTE
, 1);
1295 opcodep
[2] = (exp
[1].X_add_number
>> 8) & 255;
1296 opcodep
[3] = exp
[1].X_add_number
& 255;
1300 case mmix_operands_x_regs_z
:
1301 /* SYNCD: "X,$Y,$Z|Z". */
1303 case mmix_operands_regs
:
1304 /* Three registers, $X,$Y,$Z. */
1306 case mmix_operands_regs_z
:
1307 /* Operands "$X,$Y,$Z|Z", number of arguments checked above. */
1309 case mmix_operands_pushgo
:
1310 /* Operands "$X|X,$Y,$Z|Z", optional Z. */
1312 case mmix_operands_regs_z_opt
:
1313 /* Operands "$X,$Y,$Z|Z", with $Z|Z being optional, default 0. Any
1314 operands not completely decided yet are postponed to later in
1315 assembly (but not until link-time yet). */
1317 if ((n_operands
!= 2 && n_operands
!= 3)
1318 || (exp
[1].X_op
== O_register
&& exp
[1].X_add_number
> 255)
1320 && ((exp
[2].X_op
== O_register
1321 && exp
[2].X_add_number
> 255
1323 || (exp
[2].X_op
== O_constant
1324 && (exp
[2].X_add_number
> 255
1325 || exp
[2].X_add_number
< 0)))))
1327 as_bad (_("invalid operands to opcode %s: `%s'"),
1328 instruction
->name
, operands
);
1332 if (n_operands
== 2)
1336 /* The last operand is immediate whenever we see just two
1338 opcodep
[0] |= IMM_OFFSET_BIT
;
1340 /* Now, we could either have an implied "0" as the Z operand, or
1341 it could be the constant of a "base address plus offset". It
1342 depends on whether it is allowed; only memory operations, as
1343 signified by instruction->type and "T" and "X" operand types,
1344 and it depends on whether we find a register in the second
1346 if (exp
[1].X_op
== O_register
&& exp
[1].X_add_number
<= 255)
1348 /* A zero then; all done. */
1349 opcodep
[2] = exp
[1].X_add_number
;
1353 /* Not known as a register. Is base address plus offset
1354 allowed, or can we assume that it is a register anyway? */
1355 if ((instruction
->operands
!= mmix_operands_regs_z_opt
1356 && instruction
->operands
!= mmix_operands_x_regs_z
1357 && instruction
->operands
!= mmix_operands_pushgo
)
1358 || (instruction
->type
!= mmix_type_memaccess_octa
1359 && instruction
->type
!= mmix_type_memaccess_tetra
1360 && instruction
->type
!= mmix_type_memaccess_wyde
1361 && instruction
->type
!= mmix_type_memaccess_byte
1362 && instruction
->type
!= mmix_type_memaccess_block
1363 && instruction
->type
!= mmix_type_jsr
1364 && instruction
->type
!= mmix_type_branch
))
1366 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1367 1, exp
+ 1, 0, BFD_RELOC_MMIX_REG
);
1371 /* To avoid getting a NULL add_symbol for constants and then
1372 catching a SEGV in write_relocs since it doesn't handle
1373 constants well for relocs other than PC-relative, we need to
1374 pass expressions as symbols and use fix_new, not fix_new_exp. */
1375 sym
= make_expr_symbol (exp
+ 1);
1377 /* Mark the symbol as being OK for a reloc. */
1378 symbol_get_bfdsym (sym
)->flags
|= BSF_KEEP
;
1380 /* Now we know it can be a "base address plus offset". Add
1381 proper fixup types so we can handle this later, when we've
1382 parsed everything. */
1383 fix_new (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1384 8, sym
, 0, 0, BFD_RELOC_MMIX_BASE_PLUS_OFFSET
);
1388 if (exp
[1].X_op
== O_register
)
1389 opcodep
[2] = exp
[1].X_add_number
;
1391 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1392 1, exp
+ 1, 0, BFD_RELOC_MMIX_REG
);
1394 /* In mmixal compatibility mode, we allow special registers as
1395 constants for the Z operand. They have 256 added to their
1396 register numbers, so the right thing will happen if we just treat
1397 those as constants. */
1398 if (exp
[2].X_op
== O_register
&& exp
[2].X_add_number
<= 255)
1399 opcodep
[3] = exp
[2].X_add_number
;
1400 else if (exp
[2].X_op
== O_constant
1401 || (exp
[2].X_op
== O_register
&& exp
[2].X_add_number
> 255))
1403 opcodep
[3] = exp
[2].X_add_number
;
1404 opcodep
[0] |= IMM_OFFSET_BIT
;
1407 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1409 (instruction
->operands
== mmix_operands_set
1410 || instruction
->operands
== mmix_operands_regs
)
1411 ? BFD_RELOC_MMIX_REG
: BFD_RELOC_MMIX_REG_OR_BYTE
);
1414 case mmix_operands_pop
:
1415 /* POP, one eight and one 16-bit operand. */
1416 if (n_operands
== 0 && ! mmix_gnu_syntax
)
1418 if (n_operands
== 1 && ! mmix_gnu_syntax
)
1419 goto a_single_24_bit_number_operand
;
1421 case mmix_operands_reg_yz
:
1422 /* A register and a 16-bit unsigned number. */
1424 || exp
[1].X_op
== O_register
1425 || (exp
[1].X_op
== O_constant
1426 && (exp
[1].X_add_number
> 0xffff || exp
[1].X_add_number
< 0)))
1428 as_bad (_("invalid operands to opcode %s: `%s'"),
1429 instruction
->name
, operands
);
1433 if (exp
[1].X_op
== O_constant
)
1435 opcodep
[2] = (exp
[1].X_add_number
>> 8) & 255;
1436 opcodep
[3] = exp
[1].X_add_number
& 255;
1439 /* FIXME: This doesn't bring us unsignedness checking. */
1440 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1441 2, exp
+ 1, 0, BFD_RELOC_16
);
1444 case mmix_operands_jmp
:
1445 /* A JMP. Everything is already done. */
1448 case mmix_operands_roundregs
:
1449 /* Two registers with optional rounding mode or constant in between. */
1450 if ((n_operands
== 3 && exp
[2].X_op
== O_constant
)
1451 || (n_operands
== 2 && exp
[1].X_op
== O_constant
))
1453 as_bad (_("invalid operands to opcode %s: `%s'"),
1454 instruction
->name
, operands
);
1458 case mmix_operands_roundregs_z
:
1459 /* Like FLOT, "$X,ROUND_MODE,$Z|Z", but the rounding mode is
1460 optional and can be the corresponding constant. */
1462 /* Which exp index holds the second operand (not the rounding
1464 int op2no
= n_operands
- 1;
1466 if ((n_operands
!= 2 && n_operands
!= 3)
1467 || ((exp
[op2no
].X_op
== O_register
1468 && exp
[op2no
].X_add_number
> 255)
1469 || (exp
[op2no
].X_op
== O_constant
1470 && (exp
[op2no
].X_add_number
> 255
1471 || exp
[op2no
].X_add_number
< 0)))
1473 /* We don't allow for the rounding mode to be deferred; it
1474 must be determined in the "first pass". It cannot be a
1475 symbol equated to a rounding mode, but defined after
1477 && ((exp
[1].X_op
== O_register
1478 && exp
[1].X_add_number
< 512)
1479 || (exp
[1].X_op
== O_constant
1480 && (exp
[1].X_add_number
< 0
1481 || exp
[1].X_add_number
> 4))
1482 || (exp
[1].X_op
!= O_register
1483 && exp
[1].X_op
!= O_constant
))))
1485 as_bad (_("invalid operands to opcode %s: `%s'"),
1486 instruction
->name
, operands
);
1490 /* Add rounding mode if present. */
1491 if (n_operands
== 3)
1492 opcodep
[2] = exp
[1].X_add_number
& 255;
1494 if (exp
[op2no
].X_op
== O_register
)
1495 opcodep
[3] = exp
[op2no
].X_add_number
;
1496 else if (exp
[op2no
].X_op
== O_constant
)
1498 opcodep
[3] = exp
[op2no
].X_add_number
;
1499 opcodep
[0] |= IMM_OFFSET_BIT
;
1502 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1504 instruction
->operands
== mmix_operands_roundregs
1505 ? BFD_RELOC_MMIX_REG
1506 : BFD_RELOC_MMIX_REG_OR_BYTE
);
1510 case mmix_operands_sync
:
1511 a_single_24_bit_number_operand
:
1513 || exp
[0].X_op
== O_register
1514 || (exp
[0].X_op
== O_constant
1515 && (exp
[0].X_add_number
> 0xffffff || exp
[0].X_add_number
< 0)))
1517 as_bad (_("invalid operands to opcode %s: `%s'"),
1518 instruction
->name
, operands
);
1522 if (exp
[0].X_op
== O_constant
)
1524 opcodep
[1] = (exp
[0].X_add_number
>> 16) & 255;
1525 opcodep
[2] = (exp
[0].X_add_number
>> 8) & 255;
1526 opcodep
[3] = exp
[0].X_add_number
& 255;
1529 /* FIXME: This doesn't bring us unsignedness checking. */
1530 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1531 3, exp
+ 0, 0, BFD_RELOC_24
);
1534 case mmix_operands_neg
:
1535 /* Operands "$X,Y,$Z|Z"; NEG or NEGU. Y is optional, 0 is default. */
1537 if ((n_operands
!= 3 && n_operands
!= 2)
1538 || (n_operands
== 3 && exp
[1].X_op
== O_register
)
1539 || ((exp
[1].X_op
== O_constant
|| exp
[1].X_op
== O_register
)
1540 && (exp
[1].X_add_number
> 255 || exp
[1].X_add_number
< 0))
1542 && ((exp
[2].X_op
== O_register
&& exp
[2].X_add_number
> 255)
1543 || (exp
[2].X_op
== O_constant
1544 && (exp
[2].X_add_number
> 255
1545 || exp
[2].X_add_number
< 0)))))
1547 as_bad (_("invalid operands to opcode %s: `%s'"),
1548 instruction
->name
, operands
);
1552 if (n_operands
== 2)
1554 if (exp
[1].X_op
== O_register
)
1555 opcodep
[3] = exp
[1].X_add_number
;
1556 else if (exp
[1].X_op
== O_constant
)
1558 opcodep
[3] = exp
[1].X_add_number
;
1559 opcodep
[0] |= IMM_OFFSET_BIT
;
1562 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1563 1, exp
+ 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE
);
1567 if (exp
[1].X_op
== O_constant
)
1568 opcodep
[2] = exp
[1].X_add_number
;
1570 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1571 1, exp
+ 1, 0, BFD_RELOC_8
);
1573 if (exp
[2].X_op
== O_register
)
1574 opcodep
[3] = exp
[2].X_add_number
;
1575 else if (exp
[2].X_op
== O_constant
)
1577 opcodep
[3] = exp
[2].X_add_number
;
1578 opcodep
[0] |= IMM_OFFSET_BIT
;
1581 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1582 1, exp
+ 2, 0, BFD_RELOC_MMIX_REG_OR_BYTE
);
1585 case mmix_operands_regaddr
:
1586 /* A GETA/branch-type. */
1589 case mmix_operands_get
:
1590 /* "$X,spec_reg"; GET.
1591 Like with rounding modes, we demand that the special register or
1592 symbol is already defined when we get here at the point of use. */
1594 || (exp
[1].X_op
== O_register
1595 && (exp
[1].X_add_number
< 256 || exp
[1].X_add_number
>= 512))
1596 || (exp
[1].X_op
== O_constant
1597 && (exp
[1].X_add_number
< 0 || exp
[1].X_add_number
> 256))
1598 || (exp
[1].X_op
!= O_constant
&& exp
[1].X_op
!= O_register
))
1600 as_bad (_("invalid operands to opcode %s: `%s'"),
1601 instruction
->name
, operands
);
1605 opcodep
[3] = exp
[1].X_add_number
- 256;
1608 case mmix_operands_put
:
1609 /* "spec_reg,$Z|Z"; PUT. */
1611 || (exp
[0].X_op
== O_register
1612 && (exp
[0].X_add_number
< 256 || exp
[0].X_add_number
>= 512))
1613 || (exp
[0].X_op
== O_constant
1614 && (exp
[0].X_add_number
< 0 || exp
[0].X_add_number
> 256))
1615 || (exp
[0].X_op
!= O_constant
&& exp
[0].X_op
!= O_register
))
1617 as_bad (_("invalid operands to opcode %s: `%s'"),
1618 instruction
->name
, operands
);
1622 opcodep
[1] = exp
[0].X_add_number
- 256;
1624 /* Note that the Y field is zero. */
1626 if (exp
[1].X_op
== O_register
)
1627 opcodep
[3] = exp
[1].X_add_number
;
1628 else if (exp
[1].X_op
== O_constant
)
1630 opcodep
[3] = exp
[1].X_add_number
;
1631 opcodep
[0] |= IMM_OFFSET_BIT
;
1634 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1635 1, exp
+ 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE
);
1638 case mmix_operands_save
:
1641 || exp
[1].X_op
!= O_constant
1642 || exp
[1].X_add_number
!= 0)
1644 as_bad (_("invalid operands to opcode %s: `%s'"),
1645 instruction
->name
, operands
);
1650 case mmix_operands_unsave
:
1651 if (n_operands
< 2 && ! mmix_gnu_syntax
)
1653 if (n_operands
== 1)
1655 if (exp
[0].X_op
== O_register
)
1656 opcodep
[3] = exp
[0].X_add_number
;
1658 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1659 1, exp
, 0, BFD_RELOC_MMIX_REG
);
1664 /* "0,$Z"; UNSAVE. */
1666 || exp
[0].X_op
!= O_constant
1667 || exp
[0].X_add_number
!= 0
1668 || exp
[1].X_op
== O_constant
1669 || (exp
[1].X_op
== O_register
1670 && exp
[1].X_add_number
> 255))
1672 as_bad (_("invalid operands to opcode %s: `%s'"),
1673 instruction
->name
, operands
);
1677 if (exp
[1].X_op
== O_register
)
1678 opcodep
[3] = exp
[1].X_add_number
;
1680 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1681 1, exp
+ 1, 0, BFD_RELOC_MMIX_REG
);
1684 case mmix_operands_xyz_opt
:
1685 /* SWYM, TRIP, TRAP: zero, one, two or three operands. It's
1686 unspecified whether operands are registers or constants, but
1687 when we find register syntax, we require operands to be literal and
1689 if (n_operands
== 0 && ! mmix_gnu_syntax
)
1690 /* Zeros are in place - nothing needs to be done for zero
1691 operands. We don't allow this in GNU syntax mode, because it
1692 was believed that the risk of missing to supply an operand is
1693 higher than the benefit of not having to specify a zero. */
1695 else if (n_operands
== 1 && exp
[0].X_op
!= O_register
)
1697 if (exp
[0].X_op
== O_constant
)
1699 if (exp
[0].X_add_number
> 255*256*256
1700 || exp
[0].X_add_number
< 0)
1702 as_bad (_("invalid operands to opcode %s: `%s'"),
1703 instruction
->name
, operands
);
1708 opcodep
[1] = (exp
[0].X_add_number
>> 16) & 255;
1709 opcodep
[2] = (exp
[0].X_add_number
>> 8) & 255;
1710 opcodep
[3] = exp
[0].X_add_number
& 255;
1714 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1715 3, exp
, 0, BFD_RELOC_24
);
1717 else if (n_operands
== 2
1718 && exp
[0].X_op
!= O_register
1719 && exp
[1].X_op
!= O_register
)
1723 if (exp
[0].X_op
== O_constant
)
1725 if (exp
[0].X_add_number
> 255
1726 || exp
[0].X_add_number
< 0)
1728 as_bad (_("invalid operands to opcode %s: `%s'"),
1729 instruction
->name
, operands
);
1733 opcodep
[1] = exp
[0].X_add_number
& 255;
1736 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1737 1, exp
, 0, BFD_RELOC_8
);
1739 if (exp
[1].X_op
== O_constant
)
1741 if (exp
[1].X_add_number
> 255*256
1742 || exp
[1].X_add_number
< 0)
1744 as_bad (_("invalid operands to opcode %s: `%s'"),
1745 instruction
->name
, operands
);
1750 opcodep
[2] = (exp
[1].X_add_number
>> 8) & 255;
1751 opcodep
[3] = exp
[1].X_add_number
& 255;
1755 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1756 2, exp
+ 1, 0, BFD_RELOC_16
);
1758 else if (n_operands
== 3
1759 && exp
[0].X_op
!= O_register
1760 && exp
[1].X_op
!= O_register
1761 && exp
[2].X_op
!= O_register
)
1763 /* Three operands. */
1765 if (exp
[0].X_op
== O_constant
)
1767 if (exp
[0].X_add_number
> 255
1768 || exp
[0].X_add_number
< 0)
1770 as_bad (_("invalid operands to opcode %s: `%s'"),
1771 instruction
->name
, operands
);
1775 opcodep
[1] = exp
[0].X_add_number
& 255;
1778 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1779 1, exp
, 0, BFD_RELOC_8
);
1781 if (exp
[1].X_op
== O_constant
)
1783 if (exp
[1].X_add_number
> 255
1784 || exp
[1].X_add_number
< 0)
1786 as_bad (_("invalid operands to opcode %s: `%s'"),
1787 instruction
->name
, operands
);
1791 opcodep
[2] = exp
[1].X_add_number
& 255;
1794 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1795 1, exp
+ 1, 0, BFD_RELOC_8
);
1797 if (exp
[2].X_op
== O_constant
)
1799 if (exp
[2].X_add_number
> 255
1800 || exp
[2].X_add_number
< 0)
1802 as_bad (_("invalid operands to opcode %s: `%s'"),
1803 instruction
->name
, operands
);
1807 opcodep
[3] = exp
[2].X_add_number
& 255;
1810 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1811 1, exp
+ 2, 0, BFD_RELOC_8
);
1815 /* We can't get here for other cases. */
1816 gas_assert (n_operands
<= 3);
1818 /* The meaning of operands to TRIP and TRAP is not defined (and
1819 SWYM operands aren't enforced in mmixal, so let's avoid
1820 that). We add combinations not handled above here as we find
1821 them and as they're reported. */
1822 if (n_operands
== 3)
1824 /* Don't require non-register operands. Always generate
1825 fixups, so we don't have to copy lots of code and create
1826 maintenance problems. TRIP is supposed to be a rare
1827 instruction, so the overhead should not matter. We
1828 aren't allowed to fix_new_exp for an expression which is
1829 an O_register at this point, however.
1831 Don't use BFD_RELOC_MMIX_REG_OR_BYTE as that modifies
1832 the insn for a register in the Z field and we want
1834 if (exp
[0].X_op
== O_register
)
1835 opcodep
[1] = exp
[0].X_add_number
;
1837 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1838 1, exp
, 0, BFD_RELOC_8
);
1839 if (exp
[1].X_op
== O_register
)
1840 opcodep
[2] = exp
[1].X_add_number
;
1842 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1843 1, exp
+ 1, 0, BFD_RELOC_8
);
1844 if (exp
[2].X_op
== O_register
)
1845 opcodep
[3] = exp
[2].X_add_number
;
1847 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1848 1, exp
+ 2, 0, BFD_RELOC_8
);
1850 else if (n_operands
== 2)
1852 if (exp
[0].X_op
== O_register
)
1853 opcodep
[1] = exp
[0].X_add_number
;
1855 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 1,
1856 1, exp
, 0, BFD_RELOC_8
);
1857 if (exp
[1].X_op
== O_register
)
1858 opcodep
[3] = exp
[1].X_add_number
;
1860 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 2,
1861 2, exp
+ 1, 0, BFD_RELOC_16
);
1865 /* We can't get here for other cases. */
1866 gas_assert (n_operands
== 1 && exp
[0].X_op
== O_register
);
1868 opcodep
[3] = exp
[0].X_add_number
;
1873 case mmix_operands_resume
:
1874 if (n_operands
== 0 && ! mmix_gnu_syntax
)
1878 || exp
[0].X_op
== O_register
1879 || (exp
[0].X_op
== O_constant
1880 && (exp
[0].X_add_number
< 0
1881 || exp
[0].X_add_number
> 255)))
1883 as_bad (_("invalid operands to opcode %s: `%s'"),
1884 instruction
->name
, operands
);
1888 if (exp
[0].X_op
== O_constant
)
1889 opcodep
[3] = exp
[0].X_add_number
;
1891 fix_new_exp (opc_fragP
, opcodep
- opc_fragP
->fr_literal
+ 3,
1892 1, exp
+ 0, 0, BFD_RELOC_8
);
1895 case mmix_operands_pushj
:
1896 /* All is done for PUSHJ already. */
1900 BAD_CASE (instruction
->operands
);
1904 /* For the benefit of insns that start with a digit, we assemble by way of
1905 tc_unrecognized_line too, through this function. */
1908 mmix_assemble_return_nonzero (char *str
)
1910 int last_error_count
= had_errors ();
1914 /* Normal instruction handling downcases, so we must too. */
1915 while (ISALNUM (*s2
))
1917 if (ISUPPER ((unsigned char) *s2
))
1918 *s2
= TOLOWER (*s2
);
1922 /* Cut the line for sake of the assembly. */
1923 for (s2
= str
; *s2
&& *s2
!= '\n'; s2
++)
1931 return had_errors () == last_error_count
;
1934 /* The PREFIX pseudo. */
1937 s_prefix (int unused ATTRIBUTE_UNUSED
)
1944 c
= get_symbol_name (&p
);
1946 /* Resetting prefix? */
1947 if (*p
== ':' && p
[1] == 0)
1948 mmix_current_prefix
= NULL
;
1951 /* Put this prefix on the mmix symbols obstack. We could malloc and
1952 free it separately, but then we'd have to worry about that.
1953 People using up memory on prefixes have other problems. */
1954 obstack_grow (&mmix_sym_obstack
, p
, strlen (p
) + 1);
1955 p
= obstack_finish (&mmix_sym_obstack
);
1957 /* Accumulate prefixes, and strip a leading ':'. */
1958 if (mmix_current_prefix
!= NULL
|| *p
== ':')
1959 p
= mmix_prefix_name (p
);
1961 mmix_current_prefix
= p
;
1964 (void) restore_line_pointer (c
);
1966 mmix_handle_rest_of_empty_line ();
1969 /* We implement prefixes by using the tc_canonicalize_symbol_name hook,
1970 and store each prefixed name on a (separate) obstack. This means that
1971 the name is on the "notes" obstack in non-prefixed form and on the
1972 mmix_sym_obstack in prefixed form, but currently it is not worth
1973 rewriting the whole GAS symbol handling to improve "hooking" to avoid
1974 that. (It might be worth a rewrite for other reasons, though). */
1977 mmix_prefix_name (char *shortname
)
1979 if (*shortname
== ':')
1980 return shortname
+ 1;
1982 if (mmix_current_prefix
== NULL
)
1983 as_fatal (_("internal: mmix_prefix_name but empty prefix"));
1985 if (*shortname
== '$')
1988 obstack_grow (&mmix_sym_obstack
, mmix_current_prefix
,
1989 strlen (mmix_current_prefix
));
1990 obstack_grow (&mmix_sym_obstack
, shortname
, strlen (shortname
) + 1);
1991 return obstack_finish (&mmix_sym_obstack
);
1994 /* The GREG pseudo. At LABEL, we have the name of a symbol that we
1995 want to make a register symbol, and which should be initialized with
1996 the value in the expression at INPUT_LINE_POINTER (defaulting to 0).
1997 Either and (perhaps less meaningful) both may be missing. LABEL must
1998 be persistent, perhaps allocated on an obstack. */
2001 mmix_greg_internal (char *label
)
2003 expressionS
*expP
= &mmix_raw_gregs
[n_of_raw_gregs
].exp
;
2006 /* Don't set the section to register contents section before the
2007 expression has been parsed; it may refer to the current position. */
2008 section
= expression (expP
);
2010 /* FIXME: Check that no expression refers to the register contents
2011 section. May need to be done in elf64-mmix.c. */
2012 if (expP
->X_op
== O_absent
)
2014 /* Default to zero if the expression was absent. */
2015 expP
->X_op
= O_constant
;
2016 expP
->X_add_number
= 0;
2017 expP
->X_unsigned
= 0;
2018 expP
->X_add_symbol
= NULL
;
2019 expP
->X_op_symbol
= NULL
;
2022 if (section
== undefined_section
)
2024 /* This is an error or a LOC with an expression involving
2025 forward references. For the expression to be correctly
2026 evaluated, we need to force a proper symbol; gas loses track
2027 of the segment for "local symbols". */
2028 if (expP
->X_op
== O_add
)
2030 symbol_get_value_expression (expP
->X_op_symbol
);
2031 symbol_get_value_expression (expP
->X_add_symbol
);
2035 gas_assert (expP
->X_op
== O_symbol
);
2036 symbol_get_value_expression (expP
->X_add_symbol
);
2040 /* We must handle prefixes here, as we save the labels and expressions
2041 to be output later. */
2042 mmix_raw_gregs
[n_of_raw_gregs
].label
2043 = mmix_current_prefix
== NULL
? label
: mmix_prefix_name (label
);
2045 if (n_of_raw_gregs
== MAX_GREGS
- 1)
2046 as_bad (_("too many GREG registers allocated (max %d)"), MAX_GREGS
);
2050 mmix_handle_rest_of_empty_line ();
2053 /* The ".greg label,expr" worker. */
2056 s_greg (int unused ATTRIBUTE_UNUSED
)
2061 /* This will skip over what can be a symbol and zero out the next
2062 character, which we assume is a ',' or other meaningful delimiter.
2063 What comes after that is the initializer expression for the
2065 c
= get_symbol_name (&p
);
2068 c
= * ++ input_line_pointer
;
2070 if (! is_end_of_line
[(unsigned char) c
])
2071 input_line_pointer
++;
2075 /* The label must be persistent; it's not used until after all input
2077 obstack_grow (&mmix_sym_obstack
, p
, strlen (p
) + 1);
2078 mmix_greg_internal (obstack_finish (&mmix_sym_obstack
));
2081 mmix_greg_internal (NULL
);
2084 /* The "BSPEC expr" worker. */
2087 s_bspec (int unused ATTRIBUTE_UNUSED
)
2091 char secname
[sizeof (MMIX_OTHER_SPEC_SECTION_PREFIX
) + 20]
2092 = MMIX_OTHER_SPEC_SECTION_PREFIX
;
2096 /* Get a constant expression which we can evaluate *now*. Supporting
2097 more complex (though assembly-time computable) expressions is
2098 feasible but Too Much Work for something of unknown usefulness like
2100 expsec
= expression (&exp
);
2101 mmix_handle_rest_of_empty_line ();
2103 /* Check that we don't have another BSPEC in progress. */
2106 as_bad (_("BSPEC already active. Nesting is not supported."));
2110 if (exp
.X_op
!= O_constant
2111 || expsec
!= absolute_section
2112 || exp
.X_add_number
< 0
2113 || exp
.X_add_number
> 65535)
2115 as_bad (_("invalid BSPEC expression"));
2116 exp
.X_add_number
= 0;
2119 n
= (int) exp
.X_add_number
;
2121 sprintf (secname
+ strlen (MMIX_OTHER_SPEC_SECTION_PREFIX
), "%d", n
);
2122 sec
= bfd_get_section_by_name (stdoutput
, secname
);
2125 /* We need a non-volatile name as it will be stored in the section
2127 char *newsecname
= xstrdup (secname
);
2128 sec
= bfd_make_section (stdoutput
, newsecname
);
2131 as_fatal (_("can't create section %s"), newsecname
);
2133 if (!bfd_set_section_flags (stdoutput
, sec
,
2134 bfd_get_section_flags (stdoutput
, sec
)
2136 as_fatal (_("can't set section flags for section %s"), newsecname
);
2139 /* Tell ELF about the pending section change. */
2140 obj_elf_section_change_hook ();
2141 subseg_set (sec
, 0);
2143 /* Save position for missing ESPEC. */
2144 bspec_file
= as_where (&bspec_line
);
2149 /* The "ESPEC" worker. */
2152 s_espec (int unused ATTRIBUTE_UNUSED
)
2154 /* First, check that we *do* have a BSPEC in progress. */
2157 as_bad (_("ESPEC without preceding BSPEC"));
2161 mmix_handle_rest_of_empty_line ();
2164 /* When we told ELF about the section change in s_bspec, it stored the
2165 previous section for us so we can get at it with the equivalent of a
2166 .previous pseudo. */
2167 obj_elf_previous (0);
2170 /* The " .local expr" and " local expr" worker. We make a BFD_MMIX_LOCAL
2171 relocation against the current position against the expression.
2172 Implementing this by means of contents in a section lost. */
2175 mmix_s_local (int unused ATTRIBUTE_UNUSED
)
2179 /* Don't set the section to register contents section before the
2180 expression has been parsed; it may refer to the current position in
2181 some contorted way. */
2184 if (exp
.X_op
== O_absent
)
2186 as_bad (_("missing local expression"));
2189 else if (exp
.X_op
== O_register
)
2191 /* fix_new_exp doesn't like O_register. Should be configurable.
2192 We're fine with a constant here, though. */
2193 exp
.X_op
= O_constant
;
2196 fix_new_exp (frag_now
, 0, 0, &exp
, 0, BFD_RELOC_MMIX_LOCAL
);
2197 mmix_handle_rest_of_empty_line ();
2200 /* Set fragP->fr_var to the initial guess of the size of a relaxable insn
2201 and return it. Sizes of other instructions are not known. This
2202 function may be called multiple times. */
2205 md_estimate_size_before_relax (fragS
*fragP
, segT segment
)
2209 #define HANDLE_RELAXABLE(state) \
2210 case ENCODE_RELAX (state, STATE_UNDF): \
2211 if (fragP->fr_symbol != NULL \
2212 && S_GET_SEGMENT (fragP->fr_symbol) == segment \
2213 && !S_IS_WEAK (fragP->fr_symbol)) \
2215 /* The symbol lies in the same segment - a relaxable case. */ \
2217 = ENCODE_RELAX (state, STATE_ZERO); \
2221 switch (fragP
->fr_subtype
)
2223 HANDLE_RELAXABLE (STATE_GETA
);
2224 HANDLE_RELAXABLE (STATE_BCC
);
2225 HANDLE_RELAXABLE (STATE_JMP
);
2227 case ENCODE_RELAX (STATE_PUSHJ
, STATE_UNDF
):
2228 if (fragP
->fr_symbol
!= NULL
2229 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment
2230 && !S_IS_WEAK (fragP
->fr_symbol
))
2231 /* The symbol lies in the same segment - a relaxable case. */
2232 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PUSHJ
, STATE_ZERO
);
2233 else if (pushj_stubs
)
2234 /* If we're to generate stubs, assume we can reach a stub after
2236 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PUSHJSTUB
, STATE_ZERO
);
2238 case ENCODE_RELAX (STATE_PUSHJ
, STATE_ZERO
):
2239 case ENCODE_RELAX (STATE_PUSHJSTUB
, STATE_ZERO
):
2240 /* We need to distinguish different relaxation rounds. */
2241 seg_info (segment
)->tc_segment_info_data
.last_stubfrag
= fragP
;
2244 case ENCODE_RELAX (STATE_GETA
, STATE_ZERO
):
2245 case ENCODE_RELAX (STATE_BCC
, STATE_ZERO
):
2246 case ENCODE_RELAX (STATE_JMP
, STATE_ZERO
):
2247 /* When relaxing a section for the second time, we don't need to do
2248 anything except making sure that fr_var is set right. */
2251 case STATE_GREG_DEF
:
2252 length
= fragP
->tc_frag_data
!= NULL
? 0 : 8;
2253 fragP
->fr_var
= length
;
2255 /* Don't consult the relax_table; it isn't valid for this
2261 BAD_CASE (fragP
->fr_subtype
);
2264 length
= mmix_relax_table
[fragP
->fr_subtype
].rlx_length
;
2265 fragP
->fr_var
= length
;
2270 /* Turn a string in input_line_pointer into a floating point constant of type
2271 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
2272 emitted is stored in *sizeP . An error message is returned, or NULL on
2276 md_atof (int type
, char *litP
, int *sizeP
)
2280 /* FIXME: Having 'f' in FLT_CHARS (and here) makes it
2281 problematic to also have a forward reference in an expression.
2282 The testsuite wants it, and it's customary.
2283 We'll deal with the real problems when they come; we share the
2284 problem with most other ports. */
2285 return ieee_md_atof (type
, litP
, sizeP
, TRUE
);
2288 /* Convert variable-sized frags into one or more fixups. */
2291 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
, segT sec ATTRIBUTE_UNUSED
,
2294 /* Pointer to first byte in variable-sized part of the frag. */
2297 /* Pointer to first opcode byte in frag. */
2300 /* Size in bytes of variable-sized part of frag. */
2301 int var_part_size
= 0;
2303 /* This is part of *fragP. It contains all information about addresses
2304 and offsets to varying parts. */
2306 unsigned long var_part_offset
;
2308 /* This is the frag for the opcode. It, rather than fragP, must be used
2309 when emitting a frag for the opcode. */
2310 fragS
*opc_fragP
= fragP
->tc_frag_data
;
2313 /* Where, in file space, does addr point? */
2314 bfd_vma target_address
;
2315 bfd_vma opcode_address
;
2317 know (fragP
->fr_type
== rs_machine_dependent
);
2319 var_part_offset
= fragP
->fr_fix
;
2320 var_partp
= fragP
->fr_literal
+ var_part_offset
;
2321 opcodep
= fragP
->fr_opcode
;
2323 symbolP
= fragP
->fr_symbol
;
2326 = ((symbolP
? S_GET_VALUE (symbolP
) : 0) + fragP
->fr_offset
);
2328 /* The opcode that would be extended is the last four "fixed" bytes. */
2329 opcode_address
= fragP
->fr_address
+ fragP
->fr_fix
- 4;
2331 switch (fragP
->fr_subtype
)
2333 case ENCODE_RELAX (STATE_PUSHJSTUB
, STATE_ZERO
):
2334 /* Setting the unknown bits to 0 seems the most appropriate. */
2335 mmix_set_geta_branch_offset (opcodep
, 0);
2336 tmpfixP
= fix_new (opc_fragP
, opcodep
- opc_fragP
->fr_literal
, 8,
2337 fragP
->fr_symbol
, fragP
->fr_offset
, 1,
2338 BFD_RELOC_MMIX_PUSHJ_STUBBABLE
);
2339 COPY_FR_WHERE_TO_FX (fragP
, tmpfixP
);
2343 case ENCODE_RELAX (STATE_GETA
, STATE_ZERO
):
2344 case ENCODE_RELAX (STATE_BCC
, STATE_ZERO
):
2345 case ENCODE_RELAX (STATE_PUSHJ
, STATE_ZERO
):
2346 mmix_set_geta_branch_offset (opcodep
, target_address
- opcode_address
);
2350 = fix_new (opc_fragP
, opcodep
- opc_fragP
->fr_literal
, 4,
2351 fragP
->fr_symbol
, fragP
->fr_offset
, 1,
2352 BFD_RELOC_MMIX_ADDR19
);
2353 COPY_FR_WHERE_TO_FX (fragP
, tmpfixP
);
2358 case ENCODE_RELAX (STATE_JMP
, STATE_ZERO
):
2359 mmix_set_jmp_offset (opcodep
, target_address
- opcode_address
);
2363 = fix_new (opc_fragP
, opcodep
- opc_fragP
->fr_literal
, 4,
2364 fragP
->fr_symbol
, fragP
->fr_offset
, 1,
2365 BFD_RELOC_MMIX_ADDR27
);
2366 COPY_FR_WHERE_TO_FX (fragP
, tmpfixP
);
2371 case STATE_GREG_DEF
:
2372 if (fragP
->tc_frag_data
== NULL
)
2374 /* We must initialize data that's supposed to be "fixed up" to
2375 avoid emitting garbage, because md_apply_fix won't do
2376 anything for undefined symbols. */
2377 md_number_to_chars (var_partp
, 0, 8);
2379 = fix_new (fragP
, var_partp
- fragP
->fr_literal
, 8,
2380 fragP
->fr_symbol
, fragP
->fr_offset
, 0, BFD_RELOC_64
);
2381 COPY_FR_WHERE_TO_FX (fragP
, tmpfixP
);
2382 mmix_gregs
[n_of_cooked_gregs
++] = tmpfixP
;
2389 #define HANDLE_MAX_RELOC(state, reloc) \
2390 case ENCODE_RELAX (state, STATE_MAX): \
2392 = mmix_relax_table[ENCODE_RELAX (state, STATE_MAX)].rlx_length; \
2393 mmix_fill_nops (var_partp, var_part_size / 4); \
2394 if (warn_on_expansion) \
2395 as_warn_where (fragP->fr_file, fragP->fr_line, \
2396 _("operand out of range, instruction expanded")); \
2397 tmpfixP = fix_new (fragP, var_partp - fragP->fr_literal - 4, 8, \
2398 fragP->fr_symbol, fragP->fr_offset, 1, reloc); \
2399 COPY_FR_WHERE_TO_FX (fragP, tmpfixP); \
2402 HANDLE_MAX_RELOC (STATE_GETA
, BFD_RELOC_MMIX_GETA
);
2403 HANDLE_MAX_RELOC (STATE_BCC
, BFD_RELOC_MMIX_CBRANCH
);
2404 HANDLE_MAX_RELOC (STATE_PUSHJ
, BFD_RELOC_MMIX_PUSHJ
);
2405 HANDLE_MAX_RELOC (STATE_JMP
, BFD_RELOC_MMIX_JMP
);
2408 BAD_CASE (fragP
->fr_subtype
);
2412 fragP
->fr_fix
+= var_part_size
;
2416 /* Applies the desired value to the specified location.
2417 Also sets up addends for RELA type relocations.
2418 Stolen from tc-mcore.c.
2420 Note that this function isn't called when linkrelax != 0. */
2423 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT segment
)
2425 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2426 /* Note: use offsetT because it is signed, valueT is unsigned. */
2427 offsetT val
= (offsetT
) * valP
;
2429 = (fixP
->fx_addsy
== NULL
2430 ? absolute_section
: S_GET_SEGMENT (fixP
->fx_addsy
));
2432 /* If the fix is relative to a symbol which is not defined, or, (if
2433 pcrel), not in the same segment as the fix, we cannot resolve it
2435 if (fixP
->fx_addsy
!= NULL
2436 && (! S_IS_DEFINED (fixP
->fx_addsy
)
2437 || S_IS_WEAK (fixP
->fx_addsy
)
2438 || (fixP
->fx_pcrel
&& symsec
!= segment
)
2439 || (! fixP
->fx_pcrel
2440 && symsec
!= absolute_section
2441 && ((fixP
->fx_r_type
!= BFD_RELOC_MMIX_REG
2442 && fixP
->fx_r_type
!= BFD_RELOC_MMIX_REG_OR_BYTE
)
2443 || symsec
!= reg_section
))))
2448 else if (fixP
->fx_r_type
== BFD_RELOC_MMIX_LOCAL
2449 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2450 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2452 /* These are never "fixed". */
2457 /* We assume every other relocation is "fixed". */
2460 switch (fixP
->fx_r_type
)
2467 case BFD_RELOC_64_PCREL
:
2468 case BFD_RELOC_32_PCREL
:
2469 case BFD_RELOC_24_PCREL
:
2470 case BFD_RELOC_16_PCREL
:
2471 case BFD_RELOC_8_PCREL
:
2472 md_number_to_chars (buf
, val
, fixP
->fx_size
);
2475 case BFD_RELOC_MMIX_ADDR19
:
2478 /* This shouldn't happen. */
2479 BAD_CASE (fixP
->fx_r_type
);
2483 case BFD_RELOC_MMIX_GETA
:
2484 case BFD_RELOC_MMIX_CBRANCH
:
2485 case BFD_RELOC_MMIX_PUSHJ
:
2486 case BFD_RELOC_MMIX_PUSHJ_STUBBABLE
:
2487 /* If this fixup is out of range, punt to the linker to emit an
2488 error. This should only happen with -no-expand. */
2489 if (val
< -(((offsetT
) 1 << 19)/2)
2490 || val
>= ((offsetT
) 1 << 19)/2 - 1
2493 if (warn_on_expansion
)
2494 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
2495 _("operand out of range"));
2499 mmix_set_geta_branch_offset (buf
, val
);
2502 case BFD_RELOC_MMIX_ADDR27
:
2505 /* This shouldn't happen. */
2506 BAD_CASE (fixP
->fx_r_type
);
2510 case BFD_RELOC_MMIX_JMP
:
2511 /* If this fixup is out of range, punt to the linker to emit an
2512 error. This should only happen with -no-expand. */
2513 if (val
< -(((offsetT
) 1 << 27)/2)
2514 || val
>= ((offsetT
) 1 << 27)/2 - 1
2517 if (warn_on_expansion
)
2518 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
2519 _("operand out of range"));
2523 mmix_set_jmp_offset (buf
, val
);
2526 case BFD_RELOC_MMIX_REG_OR_BYTE
:
2527 if (fixP
->fx_addsy
!= NULL
2528 && (S_GET_SEGMENT (fixP
->fx_addsy
) != reg_section
2529 || S_GET_VALUE (fixP
->fx_addsy
) > 255)
2530 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
)
2532 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2533 _("invalid operands"));
2534 /* We don't want this "symbol" appearing in output, because
2541 /* If this reloc is for a Z field, we need to adjust
2542 the opcode if we got a constant here.
2543 FIXME: Can we make this more robust? */
2545 if ((fixP
->fx_where
& 3) == 3
2546 && (fixP
->fx_addsy
== NULL
2547 || S_GET_SEGMENT (fixP
->fx_addsy
) == absolute_section
))
2548 buf
[-3] |= IMM_OFFSET_BIT
;
2551 case BFD_RELOC_MMIX_REG
:
2552 if (fixP
->fx_addsy
== NULL
2553 || S_GET_SEGMENT (fixP
->fx_addsy
) != reg_section
2554 || S_GET_VALUE (fixP
->fx_addsy
) > 255)
2556 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2557 _("invalid operands"));
2564 case BFD_RELOC_MMIX_BASE_PLUS_OFFSET
:
2565 /* These are never "fixed". */
2569 case BFD_RELOC_MMIX_PUSHJ_1
:
2570 case BFD_RELOC_MMIX_PUSHJ_2
:
2571 case BFD_RELOC_MMIX_PUSHJ_3
:
2572 case BFD_RELOC_MMIX_CBRANCH_J
:
2573 case BFD_RELOC_MMIX_CBRANCH_1
:
2574 case BFD_RELOC_MMIX_CBRANCH_2
:
2575 case BFD_RELOC_MMIX_CBRANCH_3
:
2576 case BFD_RELOC_MMIX_GETA_1
:
2577 case BFD_RELOC_MMIX_GETA_2
:
2578 case BFD_RELOC_MMIX_GETA_3
:
2579 case BFD_RELOC_MMIX_JMP_1
:
2580 case BFD_RELOC_MMIX_JMP_2
:
2581 case BFD_RELOC_MMIX_JMP_3
:
2583 BAD_CASE (fixP
->fx_r_type
);
2588 /* Make sure that for completed fixups we have the value around for
2589 use by e.g. mmix_frob_file. */
2590 fixP
->fx_offset
= val
;
2593 /* A bsearch function for looking up a value against offsets for GREG
2597 cmp_greg_val_greg_symbol_fixes (const void *p1
, const void *p2
)
2599 offsetT val1
= *(offsetT
*) p1
;
2600 offsetT val2
= ((struct mmix_symbol_greg_fixes
*) p2
)->offs
;
2602 if (val1
>= val2
&& val1
< val2
+ 255)
2611 /* Generate a machine-dependent relocation. */
2614 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixP
)
2618 + (fixP
->fx_addsy
!= NULL
2619 && !S_IS_WEAK (fixP
->fx_addsy
)
2620 && !S_IS_COMMON (fixP
->fx_addsy
)
2621 ? S_GET_VALUE (fixP
->fx_addsy
) : 0);
2623 bfd_reloc_code_real_type code
= BFD_RELOC_NONE
;
2624 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2625 symbolS
*addsy
= fixP
->fx_addsy
;
2626 asection
*addsec
= addsy
== NULL
? NULL
: S_GET_SEGMENT (addsy
);
2627 asymbol
*baddsy
= addsy
!= NULL
? symbol_get_bfdsym (addsy
) : NULL
;
2629 = val
- (baddsy
== NULL
|| S_IS_COMMON (addsy
) || S_IS_WEAK (addsy
)
2630 ? 0 : bfd_asymbol_value (baddsy
));
2632 /* A single " LOCAL expression" in the wrong section will not work when
2633 linking to MMO; relocations for zero-content sections are then
2634 ignored. Normally, relocations would modify section contents, and
2635 you'd never think or be able to do something like that. The
2636 relocation resulting from a LOCAL directive doesn't have an obvious
2637 and mandatory location. I can't figure out a way to do this better
2638 than just helping the user around this limitation here; hopefully the
2639 code using the local expression is around. Putting the LOCAL
2640 semantics in a relocation still seems right; a section didn't do. */
2641 if (bfd_section_size (section
->owner
, section
) == 0)
2643 (fixP
->fx_file
, fixP
->fx_line
,
2644 fixP
->fx_r_type
== BFD_RELOC_MMIX_LOCAL
2645 /* The BFD_RELOC_MMIX_LOCAL-specific message is supposed to be
2646 user-friendly, though a little bit non-substantial. */
2647 ? _("directive LOCAL must be placed in code or data")
2648 : _("internal confusion: relocation in a section without contents"));
2650 /* FIXME: Range tests for all these. */
2651 switch (fixP
->fx_r_type
)
2658 code
= fixP
->fx_r_type
;
2660 if (addsy
== NULL
|| bfd_is_abs_section (addsec
))
2662 /* Resolve this reloc now, as md_apply_fix would have done (not
2663 called if -linkrelax). There is no point in keeping a reloc
2664 to an absolute symbol. No reloc that is subject to
2665 relaxation must be to an absolute symbol; difference
2666 involving symbols in a specific section must be signalled as
2667 an error if the relaxing cannot be expressed; having a reloc
2668 to the resolved (now absolute) value does not help. */
2669 md_number_to_chars (buf
, val
, fixP
->fx_size
);
2674 case BFD_RELOC_64_PCREL
:
2675 case BFD_RELOC_32_PCREL
:
2676 case BFD_RELOC_24_PCREL
:
2677 case BFD_RELOC_16_PCREL
:
2678 case BFD_RELOC_8_PCREL
:
2679 case BFD_RELOC_MMIX_LOCAL
:
2680 case BFD_RELOC_VTABLE_INHERIT
:
2681 case BFD_RELOC_VTABLE_ENTRY
:
2682 case BFD_RELOC_MMIX_GETA
:
2683 case BFD_RELOC_MMIX_GETA_1
:
2684 case BFD_RELOC_MMIX_GETA_2
:
2685 case BFD_RELOC_MMIX_GETA_3
:
2686 case BFD_RELOC_MMIX_CBRANCH
:
2687 case BFD_RELOC_MMIX_CBRANCH_J
:
2688 case BFD_RELOC_MMIX_CBRANCH_1
:
2689 case BFD_RELOC_MMIX_CBRANCH_2
:
2690 case BFD_RELOC_MMIX_CBRANCH_3
:
2691 case BFD_RELOC_MMIX_PUSHJ
:
2692 case BFD_RELOC_MMIX_PUSHJ_1
:
2693 case BFD_RELOC_MMIX_PUSHJ_2
:
2694 case BFD_RELOC_MMIX_PUSHJ_3
:
2695 case BFD_RELOC_MMIX_PUSHJ_STUBBABLE
:
2696 case BFD_RELOC_MMIX_JMP
:
2697 case BFD_RELOC_MMIX_JMP_1
:
2698 case BFD_RELOC_MMIX_JMP_2
:
2699 case BFD_RELOC_MMIX_JMP_3
:
2700 case BFD_RELOC_MMIX_ADDR19
:
2701 case BFD_RELOC_MMIX_ADDR27
:
2702 code
= fixP
->fx_r_type
;
2705 case BFD_RELOC_MMIX_REG_OR_BYTE
:
2706 /* If we have this kind of relocation to an unknown symbol or to the
2707 register contents section (that is, to a register), then we can't
2708 resolve the relocation here. */
2710 && (bfd_is_und_section (addsec
)
2711 || strcmp (bfd_get_section_name (addsec
->owner
, addsec
),
2712 MMIX_REG_CONTENTS_SECTION_NAME
) == 0))
2714 code
= fixP
->fx_r_type
;
2718 /* If the relocation is not to the register section or to the
2719 absolute section (a numeric value), then we have an error. */
2721 && (S_GET_SEGMENT (addsy
) != real_reg_section
2724 && ! bfd_is_abs_section (addsec
))
2727 /* Set the "immediate" bit of the insn if this relocation is to Z
2728 field when the value is a numeric value, i.e. not a register. */
2729 if ((fixP
->fx_where
& 3) == 3
2730 && (addsy
== NULL
|| bfd_is_abs_section (addsec
)))
2731 buf
[-3] |= IMM_OFFSET_BIT
;
2736 case BFD_RELOC_MMIX_BASE_PLUS_OFFSET
:
2738 && strcmp (bfd_get_section_name (addsec
->owner
, addsec
),
2739 MMIX_REG_CONTENTS_SECTION_NAME
) == 0)
2741 /* This changed into a register; the relocation is for the
2742 register-contents section. The constant part remains zero. */
2743 code
= BFD_RELOC_MMIX_REG
;
2747 /* If we've found out that this was indeed a register, then replace
2748 with the register number. The constant part is already zero.
2750 If we encounter any other defined symbol, then we must find a
2751 suitable register and emit a reloc. */
2752 if (addsy
== NULL
|| addsec
!= real_reg_section
)
2754 struct mmix_symbol_gregs
*gregs
;
2755 struct mmix_symbol_greg_fixes
*fix
;
2757 if (S_IS_DEFINED (addsy
)
2758 && !bfd_is_com_section (addsec
)
2759 && !S_IS_WEAK (addsy
))
2761 if (! symbol_section_p (addsy
) && ! bfd_is_abs_section (addsec
))
2762 as_fatal (_("internal: BFD_RELOC_MMIX_BASE_PLUS_OFFSET not resolved to section"));
2764 /* If this is an absolute symbol sufficiently near
2765 lowest_data_loc, then we canonicalize on the data
2766 section. Note that val is signed here; we may subtract
2767 lowest_data_loc which is unsigned. Careful with those
2769 if (lowest_data_loc
!= (bfd_vma
) -1
2770 && (bfd_vma
) val
+ 256 > lowest_data_loc
2771 && bfd_is_abs_section (addsec
))
2773 val
-= (offsetT
) lowest_data_loc
;
2774 addsy
= section_symbol (data_section
);
2776 /* Likewise text section. */
2777 else if (lowest_text_loc
!= (bfd_vma
) -1
2778 && (bfd_vma
) val
+ 256 > lowest_text_loc
2779 && bfd_is_abs_section (addsec
))
2781 val
-= (offsetT
) lowest_text_loc
;
2782 addsy
= section_symbol (text_section
);
2786 gregs
= *symbol_get_tc (addsy
);
2788 /* If that symbol does not have any associated GREG definitions,
2789 we can't do anything. */
2791 || (fix
= bsearch (&val
, gregs
->greg_fixes
, gregs
->n_gregs
,
2792 sizeof (gregs
->greg_fixes
[0]),
2793 cmp_greg_val_greg_symbol_fixes
)) == NULL
2794 /* The register must not point *after* the address we want. */
2796 /* Neither must the register point more than 255 bytes
2797 before the address we want. */
2798 || fix
->offs
+ 255 < val
)
2800 /* We can either let the linker allocate GREGs
2801 automatically, or emit an error. */
2802 if (allocate_undefined_gregs_in_linker
)
2804 /* The values in baddsy and addend are right. */
2805 code
= fixP
->fx_r_type
;
2809 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2810 _("no suitable GREG definition for operands"));
2815 /* Transform the base-plus-offset reloc for the actual area
2816 to a reloc for the register with the address of the area.
2817 Put addend for register in Z operand. */
2818 buf
[1] = val
- fix
->offs
;
2819 code
= BFD_RELOC_MMIX_REG
;
2821 = (bfd_get_section_by_name (stdoutput
,
2822 MMIX_REG_CONTENTS_SECTION_NAME
)
2825 addend
= fix
->fix
->fx_frag
->fr_address
+ fix
->fix
->fx_where
;
2828 else if (S_GET_VALUE (addsy
) > 255)
2829 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2830 _("invalid operands"));
2838 case BFD_RELOC_MMIX_REG
:
2840 && (bfd_is_und_section (addsec
)
2841 || strcmp (bfd_get_section_name (addsec
->owner
, addsec
),
2842 MMIX_REG_CONTENTS_SECTION_NAME
) == 0))
2844 code
= fixP
->fx_r_type
;
2849 && (addsec
!= real_reg_section
2852 && ! bfd_is_und_section (addsec
))
2853 /* Drop through to error message. */
2862 /* The others are supposed to be handled by md_apply_fix.
2863 FIXME: ... which isn't called when -linkrelax. Move over
2864 md_apply_fix code here for everything reasonable. */
2868 (fixP
->fx_file
, fixP
->fx_line
,
2869 _("operands were not reducible at assembly-time"));
2871 /* Unmark this symbol as used in a reloc, so we don't bump into a BFD
2872 assert when trying to output reg_section. FIXME: A gas bug. */
2873 fixP
->fx_addsy
= NULL
;
2877 relP
= XNEW (arelent
);
2878 gas_assert (relP
!= 0);
2879 relP
->sym_ptr_ptr
= XNEW (asymbol
*);
2880 *relP
->sym_ptr_ptr
= baddsy
;
2881 relP
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2883 relP
->addend
= addend
;
2885 /* If this had been a.out, we would have had a kludge for weak symbols
2888 relP
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2893 name
= S_GET_NAME (addsy
);
2895 name
= _("<unknown>");
2896 as_fatal (_("cannot generate relocation type for symbol %s, code %s"),
2897 name
, bfd_get_reloc_code_name (code
));
2903 /* Do some reformatting of a line. FIXME: We could transform a mmixal
2904 line into traditional (GNU?) format, unless #NO_APP, and get rid of all
2905 ugly labels_without_colons etc. */
2908 mmix_handle_mmixal (void)
2911 char *s
= input_line_pointer
;
2915 if (pending_label
!= NULL
)
2916 as_fatal (_("internal: unhandled label %s"), pending_label
);
2918 if (mmix_gnu_syntax
)
2921 /* If we're on a line with a label, check if it's a mmixal fb-label.
2922 Save an indicator and skip the label; it must be set only after all
2923 fb-labels of expressions are evaluated. */
2924 if (ISDIGIT (s
[0]) && s
[1] == 'H' && ISSPACE (s
[2]))
2926 current_fb_label
= s
[0] - '0';
2928 /* We have to skip the label, but also preserve the newlineness of
2929 the previous character, since the caller checks that. It's a
2930 mess we blame on the caller. */
2933 input_line_pointer
= s
;
2935 while (*s
&& ISSPACE (*s
) && ! is_end_of_line
[(unsigned int) *s
])
2938 /* For errors emitted here, the book-keeping is off by one; the
2939 caller is about to bump the counters. Adjust the error messages. */
2940 if (is_end_of_line
[(unsigned int) *s
])
2943 const char * name
= as_where (&line
);
2944 as_bad_where (name
, line
+ 1,
2945 _("[0-9]H labels may not appear alone on a line"));
2946 current_fb_label
= -1;
2951 const char * name
= as_where (&line
);
2952 as_bad_where (name
, line
+ 1,
2953 _("[0-9]H labels do not mix with dot-pseudos"));
2954 current_fb_label
= -1;
2957 /* Back off to the last space before the opcode so we don't handle
2958 the opcode as a label. */
2962 current_fb_label
= -1;
2966 /* If the first character is a '.', then it's a pseudodirective, not a
2967 label. Make GAS not handle label-without-colon on this line. We
2968 also don't do mmixal-specific stuff on this line. */
2969 label_without_colon_this_line
= 0;
2973 if (*s
== 0 || is_end_of_line
[(unsigned int) *s
])
2974 /* We avoid handling empty lines here. */
2977 if (is_name_beginner (*s
))
2980 /* If there is a label, skip over it. */
2981 while (*s
&& is_part_of_name (*s
))
2984 /* Find the start of the instruction or pseudo following the label,
2987 *insn
&& ISSPACE (*insn
) && ! is_end_of_line
[(unsigned int) *insn
];
2992 /* Remove a trailing ":" off labels, as they'd otherwise be considered
2993 part of the name. But don't do this for local labels. */
2994 if (s
!= input_line_pointer
&& s
[-1] == ':'
2995 && (s
- 2 != input_line_pointer
2996 || ! ISDIGIT (s
[-2])))
2998 else if (label
!= NULL
2999 /* For a lone label on a line, we don't attach it to the next
3000 instruction or MMIXAL-pseudo (getting its alignment). Thus
3001 is acts like a "normal" :-ended label. Ditto if it's
3002 followed by a non-MMIXAL pseudo. */
3003 && !is_end_of_line
[(unsigned int) *insn
]
3006 /* For labels that don't end in ":", we save it so we can later give
3007 it the same alignment and address as the associated instruction. */
3009 /* Make room for the label including the ending nul. */
3010 size_t len_0
= s
- label
+ 1;
3012 /* Save this label on the MMIX symbol obstack. Saving it on an
3013 obstack is needless for "IS"-pseudos, but it's harmless and we
3014 avoid a little code-cluttering. */
3015 obstack_grow (&mmix_sym_obstack
, label
, len_0
);
3016 pending_label
= obstack_finish (&mmix_sym_obstack
);
3017 pending_label
[len_0
- 1] = 0;
3020 /* If we have a non-MMIXAL pseudo, we have not business with the rest of
3025 /* Find local labels of operands. Look for "[0-9][FB]" where the
3026 characters before and after are not part of words. Break if a single
3027 or double quote is seen anywhere. It means we can't have local
3028 labels as part of list with mixed quoted and unquoted members for
3029 mmixal compatibility but we can't have it all. For the moment.
3030 Replace the '<N>B' or '<N>F' with MAGIC_FB_BACKWARD_CHAR<N> and
3031 MAGIC_FB_FORWARD_CHAR<N> respectively. */
3033 /* First make sure we don't have any of the magic characters on the line
3034 appearing as input. */
3038 if (is_end_of_line
[(unsigned int) c
])
3040 if (c
== MAGIC_FB_BACKWARD_CHAR
|| c
== MAGIC_FB_FORWARD_CHAR
)
3041 as_bad (_("invalid characters in input"));
3044 /* Scan again, this time looking for ';' after operands. */
3047 /* Skip the insn. */
3051 && ! is_end_of_line
[(unsigned int) *s
])
3054 /* Skip the spaces after the insn. */
3058 && ! is_end_of_line
[(unsigned int) *s
])
3061 /* Skip the operands. While doing this, replace [0-9][BF] with
3062 (MAGIC_FB_BACKWARD_CHAR|MAGIC_FB_FORWARD_CHAR)[0-9]. */
3063 while ((c
= *s
) != 0
3066 && ! is_end_of_line
[(unsigned int) c
])
3072 /* FIXME: Test-case for semi-colon in string. */
3075 && (! is_end_of_line
[(unsigned int) *s
] || *s
== ';'))
3081 else if (ISDIGIT (c
))
3083 if ((s
[1] != 'B' && s
[1] != 'F')
3084 || is_part_of_name (s
[-1])
3085 || is_part_of_name (s
[2])
3086 /* Don't treat e.g. #1F as a local-label reference. */
3087 || (s
!= input_line_pointer
&& s
[-1] == '#'))
3092 ? MAGIC_FB_BACKWARD_CHAR
: MAGIC_FB_FORWARD_CHAR
);
3100 /* Skip any spaces after the operands. */
3104 && !is_end_of_line
[(unsigned int) *s
])
3107 /* If we're now looking at a semi-colon, then it's an end-of-line
3109 mmix_next_semicolon_is_eoln
= (*s
== ';');
3111 /* Make IS into an EQU by replacing it with "= ". Only match upper-case
3112 though; let lower-case be a syntax error. */
3114 if (s
[0] == 'I' && s
[1] == 'S' && ISSPACE (s
[2]))
3119 /* Since labels can start without ":", we have to handle "X IS 42"
3120 in full here, or "X" will be parsed as a label to be set at ".". */
3121 input_line_pointer
= s
;
3123 /* Right after this function ends, line numbers will be bumped if
3124 input_line_pointer[-1] = '\n'. We want accurate line numbers for
3125 the equals call, so we bump them before the call, and make sure
3126 they aren't bumped afterwards. */
3127 bump_line_counters ();
3129 /* A fb-label is valid as an IS-label. */
3130 if (current_fb_label
>= 0)
3134 /* We need to save this name on our symbol obstack, since the
3135 string we got in fb_label_name is volatile and will change
3136 with every call to fb_label_name, like those resulting from
3137 parsing the IS-operand. */
3138 fb_name
= fb_label_name (current_fb_label
, 1);
3139 obstack_grow (&mmix_sym_obstack
, fb_name
, strlen (fb_name
) + 1);
3140 equals (obstack_finish (&mmix_sym_obstack
), 0);
3141 fb_label_instance_inc (current_fb_label
);
3142 current_fb_label
= -1;
3146 if (pending_label
== NULL
)
3147 as_bad (_("empty label field for IS"));
3149 equals (pending_label
, 0);
3150 pending_label
= NULL
;
3153 /* For mmixal, we can have comments without a comment-start
3155 mmix_handle_rest_of_empty_line ();
3156 input_line_pointer
--;
3158 input_line_pointer
[-1] = ' ';
3160 else if (s
[0] == 'G'
3162 && strncmp (s
, "GREG", 4) == 0
3163 && (ISSPACE (s
[4]) || is_end_of_line
[(unsigned char) s
[4]]))
3165 input_line_pointer
= s
+ 4;
3167 /* Right after this function ends, line numbers will be bumped if
3168 input_line_pointer[-1] = '\n'. We want accurate line numbers for
3169 the s_greg call, so we bump them before the call, and make sure
3170 they aren't bumped afterwards. */
3171 bump_line_counters ();
3173 /* A fb-label is valid as a GREG-label. */
3174 if (current_fb_label
>= 0)
3178 /* We need to save this name on our symbol obstack, since the
3179 string we got in fb_label_name is volatile and will change
3180 with every call to fb_label_name, like those resulting from
3181 parsing the IS-operand. */
3182 fb_name
= fb_label_name (current_fb_label
, 1);
3184 /* Make sure we save the canonical name and don't get bitten by
3186 obstack_1grow (&mmix_sym_obstack
, ':');
3187 obstack_grow (&mmix_sym_obstack
, fb_name
, strlen (fb_name
) + 1);
3188 mmix_greg_internal (obstack_finish (&mmix_sym_obstack
));
3189 fb_label_instance_inc (current_fb_label
);
3190 current_fb_label
= -1;
3193 mmix_greg_internal (pending_label
);
3195 /* Back up before the end-of-line marker that was skipped in
3196 mmix_greg_internal. */
3197 input_line_pointer
--;
3198 input_line_pointer
[-1] = ' ';
3200 pending_label
= NULL
;
3202 else if (pending_label
!= NULL
)
3204 input_line_pointer
+= strlen (pending_label
);
3206 /* See comment above about getting line numbers bumped. */
3207 input_line_pointer
[-1] = '\n';
3211 /* Give the value of an fb-label rewritten as in mmix_handle_mmixal, when
3212 parsing an expression.
3214 On valid calls, input_line_pointer points at a MAGIC_FB_BACKWARD_CHAR
3215 or MAGIC_FB_BACKWARD_CHAR, followed by an ascii digit for the label.
3216 We fill in the label as an expression. */
3219 mmix_fb_label (expressionS
*expP
)
3222 char *fb_internal_name
;
3224 /* This doesn't happen when not using mmixal syntax. */
3226 || (input_line_pointer
[0] != MAGIC_FB_BACKWARD_CHAR
3227 && input_line_pointer
[0] != MAGIC_FB_FORWARD_CHAR
))
3230 /* The current backward reference has augmentation 0. A forward
3231 reference has augmentation 1, unless it's the same as a fb-label on
3232 _this_ line, in which case we add one more so we don't refer to it.
3233 This is the semantics of mmixal; it differs to that of common
3234 fb-labels which refer to a here-label on the current line as a
3235 backward reference. */
3237 = fb_label_name (input_line_pointer
[1] - '0',
3238 (input_line_pointer
[0] == MAGIC_FB_FORWARD_CHAR
? 1 : 0)
3239 + ((input_line_pointer
[1] - '0' == current_fb_label
3240 && input_line_pointer
[0] == MAGIC_FB_FORWARD_CHAR
)
3243 input_line_pointer
+= 2;
3244 sym
= symbol_find_or_make (fb_internal_name
);
3246 /* We don't have to clean up unrelated fields here; we just do what the
3247 expr machinery does, but *not* just what it does for [0-9][fb], since
3248 we need to treat those as ordinary symbols sometimes; see testcases
3249 err-byte2.s and fb-2.s. */
3250 if (S_GET_SEGMENT (sym
) == absolute_section
)
3252 expP
->X_op
= O_constant
;
3253 expP
->X_add_number
= S_GET_VALUE (sym
);
3257 expP
->X_op
= O_symbol
;
3258 expP
->X_add_symbol
= sym
;
3259 expP
->X_add_number
= 0;
3263 /* See whether we need to force a relocation into the output file.
3264 This is used to force out switch and PC relative relocations when
3268 mmix_force_relocation (fixS
*fixP
)
3270 if (fixP
->fx_r_type
== BFD_RELOC_MMIX_LOCAL
3271 || fixP
->fx_r_type
== BFD_RELOC_MMIX_BASE_PLUS_OFFSET
)
3277 /* All our pcrel relocations are must-keep. Note that md_apply_fix is
3278 called *after* this, and will handle getting rid of the presumed
3279 reloc; a relocation isn't *forced* other than to be handled by
3280 md_apply_fix (or tc_gen_reloc if linkrelax). */
3284 return generic_force_reloc (fixP
);
3287 /* The location from which a PC relative jump should be calculated,
3288 given a PC relative reloc. */
3291 md_pcrel_from_section (fixS
*fixP
, segT sec
)
3293 if (fixP
->fx_addsy
!= (symbolS
*) NULL
3294 && (! S_IS_DEFINED (fixP
->fx_addsy
)
3295 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
3297 /* The symbol is undefined (or is defined but not in this section).
3298 Let the linker figure it out. */
3302 return (fixP
->fx_frag
->fr_address
+ fixP
->fx_where
);
3305 /* Adjust the symbol table. We make reg_section relative to the real
3306 register section. */
3309 mmix_adjust_symtab (void)
3312 symbolS
*regsec
= section_symbol (reg_section
);
3314 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
3315 if (S_GET_SEGMENT (sym
) == reg_section
)
3319 if (S_IS_EXTERNAL (sym
) || symbol_used_in_reloc_p (sym
))
3321 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
3324 /* Change section to the *real* register section, so it gets
3325 proper treatment when writing it out. Only do this for
3326 global symbols. This also means we don't have to check for
3328 S_SET_SEGMENT (sym
, real_reg_section
);
3332 /* This is the expansion of LABELS_WITHOUT_COLONS.
3333 We let md_start_line_hook tweak label_without_colon_this_line, and then
3334 this function returns the tweaked value, and sets it to 1 for the next
3335 line. FIXME: Very, very brittle. Not sure it works the way I
3336 thought at the time I first wrote this. */
3339 mmix_label_without_colon_this_line (void)
3341 int retval
= label_without_colon_this_line
;
3343 if (! mmix_gnu_syntax
)
3344 label_without_colon_this_line
= 1;
3349 /* This is the expansion of md_relax_frag. We go through the ordinary
3350 relax table function except when the frag is for a GREG. Then we have
3351 to check whether there's another GREG by the same value that we can
3355 mmix_md_relax_frag (segT seg
, fragS
*fragP
, long stretch
)
3357 switch (fragP
->fr_subtype
)
3359 /* Growth for this type has been handled by mmix_md_end and
3360 correctly estimated, so there's nothing more to do here. */
3361 case STATE_GREG_DEF
:
3364 case ENCODE_RELAX (STATE_PUSHJ
, STATE_ZERO
):
3366 /* We need to handle relaxation type ourselves, since relax_frag
3367 doesn't update fr_subtype if there's no size increase in the
3368 current section; when going from plain PUSHJ to a stub. This
3369 is otherwise functionally the same as relax_frag in write.c,
3370 simplified for this case. */
3375 target
= fragP
->fr_offset
;
3376 address
= fragP
->fr_address
;
3377 symbolP
= fragP
->fr_symbol
;
3383 sym_frag
= symbol_get_frag (symbolP
);
3384 know (S_GET_SEGMENT (symbolP
) != absolute_section
3385 || sym_frag
== &zero_address_frag
);
3386 target
+= S_GET_VALUE (symbolP
);
3388 /* If frag has yet to be reached on this pass, assume it will
3389 move by STRETCH just as we did. If this is not so, it will
3390 be because some frag between grows, and that will force
3394 && sym_frag
->relax_marker
!= fragP
->relax_marker
3395 && S_GET_SEGMENT (symbolP
) == seg
)
3399 aim
= target
- address
- fragP
->fr_fix
;
3400 if (aim
>= PUSHJ_0B
&& aim
<= PUSHJ_0F
)
3402 /* Target is reachable with a PUSHJ. */
3403 segment_info_type
*seginfo
= seg_info (seg
);
3405 /* If we're at the end of a relaxation round, clear the stub
3406 counter as initialization for the next round. */
3407 if (fragP
== seginfo
->tc_segment_info_data
.last_stubfrag
)
3408 seginfo
->tc_segment_info_data
.nstubs
= 0;
3412 /* Not reachable. Try a stub. */
3413 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PUSHJSTUB
, STATE_ZERO
);
3417 /* See if this PUSHJ is redirectable to a stub. */
3418 case ENCODE_RELAX (STATE_PUSHJSTUB
, STATE_ZERO
):
3420 segment_info_type
*seginfo
= seg_info (seg
);
3421 fragS
*lastfrag
= seginfo
->frchainP
->frch_last
;
3422 relax_substateT prev_type
= fragP
->fr_subtype
;
3424 /* The last frag is always an empty frag, so it suffices to look
3425 at its address to know the ending address of this section. */
3426 know (lastfrag
->fr_type
== rs_fill
3427 && lastfrag
->fr_fix
== 0
3428 && lastfrag
->fr_var
== 0);
3430 /* For this PUSHJ to be relaxable into a call to a stub, the
3431 distance must be no longer than 256k bytes from the PUSHJ to
3432 the end of the section plus the maximum size of stubs so far. */
3433 if ((lastfrag
->fr_address
3435 + PUSHJ_MAX_LEN
* seginfo
->tc_segment_info_data
.nstubs
)
3436 - (fragP
->fr_address
+ fragP
->fr_fix
)
3439 fragP
->fr_subtype
= mmix_relax_table
[prev_type
].rlx_more
;
3441 seginfo
->tc_segment_info_data
.nstubs
++;
3443 /* If we're at the end of a relaxation round, clear the stub
3444 counter as initialization for the next round. */
3445 if (fragP
== seginfo
->tc_segment_info_data
.last_stubfrag
)
3446 seginfo
->tc_segment_info_data
.nstubs
= 0;
3449 (mmix_relax_table
[fragP
->fr_subtype
].rlx_length
3450 - mmix_relax_table
[prev_type
].rlx_length
);
3453 case ENCODE_RELAX (STATE_PUSHJ
, STATE_MAX
):
3455 segment_info_type
*seginfo
= seg_info (seg
);
3457 /* Need to cover all STATE_PUSHJ states to act on the last stub
3458 frag (the end of this relax round; initialization for the
3460 if (fragP
== seginfo
->tc_segment_info_data
.last_stubfrag
)
3461 seginfo
->tc_segment_info_data
.nstubs
= 0;
3467 return relax_frag (seg
, fragP
, stretch
);
3469 case STATE_GREG_UNDF
:
3470 BAD_CASE (fragP
->fr_subtype
);
3473 as_fatal (_("internal: unexpected relax type %d:%d"),
3474 fragP
->fr_type
, fragP
->fr_subtype
);
3478 /* Various things we punt until all input is seen. */
3486 struct loc_assert_s
*loc_assert
;
3489 /* The first frag of GREG:s going into the register contents section. */
3490 fragS
*mmix_reg_contents_frags
= NULL
;
3492 /* Reset prefix. All labels reachable at this point must be
3494 mmix_current_prefix
= NULL
;
3497 as_bad_where (bspec_file
, bspec_line
, _("BSPEC without ESPEC."));
3499 /* Emit the low LOC setting of .text. */
3500 if (text_has_contents
&& lowest_text_loc
!= (bfd_vma
) -1)
3503 char locsymbol
[sizeof (":") - 1
3504 + sizeof (MMIX_LOC_SECTION_START_SYMBOL_PREFIX
) - 1
3505 + sizeof (".text")];
3507 /* An exercise in non-ISO-C-ness, this one. */
3508 sprintf (locsymbol
, ":%s%s", MMIX_LOC_SECTION_START_SYMBOL_PREFIX
,
3511 = symbol_new (locsymbol
, absolute_section
, lowest_text_loc
,
3512 &zero_address_frag
);
3513 S_SET_EXTERNAL (symbolP
);
3517 if (data_has_contents
&& lowest_data_loc
!= (bfd_vma
) -1)
3520 char locsymbol
[sizeof (":") - 1
3521 + sizeof (MMIX_LOC_SECTION_START_SYMBOL_PREFIX
) - 1
3522 + sizeof (".data")];
3524 sprintf (locsymbol
, ":%s%s", MMIX_LOC_SECTION_START_SYMBOL_PREFIX
,
3527 = symbol_new (locsymbol
, absolute_section
, lowest_data_loc
,
3528 &zero_address_frag
);
3529 S_SET_EXTERNAL (symbolP
);
3532 /* Unless GNU syntax mode, set "Main" to be a function, so the
3533 disassembler doesn't get confused when we write truly
3534 mmixal-compatible code (and don't use .type). Similarly set it
3535 global (regardless of -globalize-symbols), so the linker sees it as
3536 the start symbol in ELF mode. */
3537 mainsym
= symbol_find (MMIX_START_SYMBOL_NAME
);
3538 if (mainsym
!= NULL
&& ! mmix_gnu_syntax
)
3540 symbol_get_bfdsym (mainsym
)->flags
|= BSF_FUNCTION
;
3541 S_SET_EXTERNAL (mainsym
);
3544 /* Check that we didn't LOC into the unknown, or rather that when it
3545 was unknown, we actually change sections. */
3546 for (loc_assert
= loc_asserts
;
3548 loc_assert
= loc_assert
->next
)
3552 resolve_symbol_value (loc_assert
->loc_sym
);
3553 actual_seg
= S_GET_SEGMENT (loc_assert
->loc_sym
);
3554 if (actual_seg
!= loc_assert
->old_seg
)
3558 int e_valid
= expr_symbol_where (loc_assert
->loc_sym
, &fnam
, &line
);
3560 gas_assert (e_valid
== 1);
3561 as_bad_where (fnam
, line
,
3562 _("LOC to section unknown or indeterminable "
3565 /* Patch up the generic location data to avoid cascading
3566 error messages from later passes. (See original in
3567 write.c:relax_segment.) */
3568 fragP
= loc_assert
->frag
;
3569 fragP
->fr_type
= rs_align
;
3570 fragP
->fr_subtype
= 0;
3571 fragP
->fr_offset
= 0;
3576 if (n_of_raw_gregs
!= 0)
3578 /* Emit GREGs. They are collected in order of appearance, but must
3579 be emitted in opposite order to both have section address regno*8
3580 and the same allocation order (within a file) as mmixal. */
3581 segT this_segment
= now_seg
;
3582 subsegT this_subsegment
= now_subseg
;
3584 regsec
= bfd_make_section_old_way (stdoutput
,
3585 MMIX_REG_CONTENTS_SECTION_NAME
);
3586 subseg_set (regsec
, 0);
3588 /* Finally emit the initialization-value. Emit a variable frag, which
3589 we'll fix in md_estimate_size_before_relax. We set the initializer
3590 for the tc_frag_data field to NULL, so we can use that field for
3591 relaxation purposes. */
3592 mmix_opcode_frag
= NULL
;
3595 mmix_reg_contents_frags
= frag_now
;
3597 for (i
= n_of_raw_gregs
- 1; i
>= 0; i
--)
3599 if (mmix_raw_gregs
[i
].label
!= NULL
)
3600 /* There's a symbol. Let it refer to this location in the
3601 register contents section. The symbol must be globalized
3603 colon (mmix_raw_gregs
[i
].label
);
3605 frag_var (rs_machine_dependent
, 8, 0, STATE_GREG_UNDF
,
3606 make_expr_symbol (&mmix_raw_gregs
[i
].exp
), 0, NULL
);
3609 subseg_set (this_segment
, this_subsegment
);
3612 regsec
= bfd_get_section_by_name (stdoutput
, MMIX_REG_CONTENTS_SECTION_NAME
);
3613 /* Mark the section symbol as being OK for a reloc. */
3615 regsec
->symbol
->flags
|= BSF_KEEP
;
3617 /* Iterate over frags resulting from GREGs and move those that evidently
3618 have the same value together and point one to another.
3620 This works in time O(N^2) but since the upper bound for non-error use
3621 is 223, it's best to keep this simpler algorithm. */
3622 for (fragP
= mmix_reg_contents_frags
; fragP
!= NULL
; fragP
= fragP
->fr_next
)
3629 symbolS
*symbolP
= fragP
->fr_symbol
;
3631 if (fragP
->fr_type
!= rs_machine_dependent
3632 || fragP
->fr_subtype
!= STATE_GREG_UNDF
)
3635 /* Whatever the outcome, we will have this GREG judged merged or
3636 non-merged. Since the tc_frag_data is NULL at this point, we
3637 default to non-merged. */
3638 fragP
->fr_subtype
= STATE_GREG_DEF
;
3640 /* If we're not supposed to merge GREG definitions, then just don't
3641 look for equivalents. */
3645 osymval
= (offsetT
) S_GET_VALUE (symbolP
);
3646 osymfrag
= symbol_get_frag (symbolP
);
3648 /* If the symbol isn't defined, we can't say that another symbol
3649 equals this frag, then. FIXME: We can look at the "deepest"
3650 defined name; if a = c and b = c then obviously a == b. */
3651 if (! S_IS_DEFINED (symbolP
))
3654 oexpP
= symbol_get_value_expression (fragP
->fr_symbol
);
3656 /* If the initialization value is zero, then we must not merge them. */
3657 if (oexpP
->X_op
== O_constant
&& osymval
== 0)
3660 /* Iterate through the frags downward this one. If we find one that
3661 has the same non-zero value, move it to after this one and point
3662 to it as the equivalent. */
3663 for (fpp
= &fragP
->fr_next
; *fpp
!= NULL
; fpp
= &fpp
[0]->fr_next
)
3667 if (fp
->fr_type
!= rs_machine_dependent
3668 || fp
->fr_subtype
!= STATE_GREG_UNDF
)
3671 /* Calling S_GET_VALUE may simplify the symbol, changing from
3672 expr_section etc. so call it first. */
3673 if ((offsetT
) S_GET_VALUE (fp
->fr_symbol
) == osymval
3674 && symbol_get_frag (fp
->fr_symbol
) == osymfrag
)
3676 /* Move the frag links so the one we found equivalent comes
3677 after the current one, carefully considering that
3678 sometimes fpp == &fragP->fr_next and the moves must be a
3681 fp
->fr_next
= fragP
->fr_next
;
3682 fragP
->fr_next
= fp
;
3688 fragP
->tc_frag_data
= fp
;
3692 /* qsort function for mmix_symbol_gregs. */
3695 cmp_greg_symbol_fixes (const void *parg
, const void *qarg
)
3697 const struct mmix_symbol_greg_fixes
*p
3698 = (const struct mmix_symbol_greg_fixes
*) parg
;
3699 const struct mmix_symbol_greg_fixes
*q
3700 = (const struct mmix_symbol_greg_fixes
*) qarg
;
3702 return p
->offs
> q
->offs
? 1 : p
->offs
< q
->offs
? -1 : 0;
3705 /* Collect GREG definitions from mmix_gregs and hang them as lists sorted
3706 on increasing offsets onto each section symbol or undefined symbol.
3708 Also, remove the register convenience section so it doesn't get output
3709 as an ELF section. */
3712 mmix_frob_file (void)
3715 struct mmix_symbol_gregs
*all_greg_symbols
[MAX_GREGS
];
3716 int n_greg_symbols
= 0;
3718 /* Collect all greg fixups and decorate each corresponding symbol with
3719 the greg fixups for it. */
3720 for (i
= 0; i
< n_of_cooked_gregs
; i
++)
3724 struct mmix_symbol_gregs
*gregs
;
3727 fixP
= mmix_gregs
[i
];
3728 know (fixP
->fx_r_type
== BFD_RELOC_64
);
3730 /* This case isn't doable in general anyway, methinks. */
3731 if (fixP
->fx_subsy
!= NULL
)
3733 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3734 _("GREG expression too complicated"));
3738 sym
= fixP
->fx_addsy
;
3739 offs
= (offsetT
) fixP
->fx_offset
;
3741 /* If the symbol is defined, then it must be resolved to a section
3742 symbol at this time, or else we don't know how to handle it. */
3743 if (S_IS_DEFINED (sym
)
3744 && !bfd_is_com_section (S_GET_SEGMENT (sym
))
3745 && !S_IS_WEAK (sym
))
3747 if (! symbol_section_p (sym
)
3748 && ! bfd_is_abs_section (S_GET_SEGMENT (sym
)))
3749 as_fatal (_("internal: GREG expression not resolved to section"));
3751 offs
+= S_GET_VALUE (sym
);
3754 /* If this is an absolute symbol sufficiently near lowest_data_loc,
3755 then we canonicalize on the data section. Note that offs is
3756 signed here; we may subtract lowest_data_loc which is unsigned.
3757 Careful with those comparisons. */
3758 if (lowest_data_loc
!= (bfd_vma
) -1
3759 && (bfd_vma
) offs
+ 256 > lowest_data_loc
3760 && bfd_is_abs_section (S_GET_SEGMENT (sym
)))
3762 offs
-= (offsetT
) lowest_data_loc
;
3763 sym
= section_symbol (data_section
);
3765 /* Likewise text section. */
3766 else if (lowest_text_loc
!= (bfd_vma
) -1
3767 && (bfd_vma
) offs
+ 256 > lowest_text_loc
3768 && bfd_is_abs_section (S_GET_SEGMENT (sym
)))
3770 offs
-= (offsetT
) lowest_text_loc
;
3771 sym
= section_symbol (text_section
);
3774 gregs
= *symbol_get_tc (sym
);
3778 gregs
= XNEW (struct mmix_symbol_gregs
);
3780 symbol_set_tc (sym
, &gregs
);
3781 all_greg_symbols
[n_greg_symbols
++] = gregs
;
3784 gregs
->greg_fixes
[gregs
->n_gregs
].fix
= fixP
;
3785 gregs
->greg_fixes
[gregs
->n_gregs
++].offs
= offs
;
3788 /* For each symbol having a GREG definition, sort those definitions on
3790 for (i
= 0; i
< n_greg_symbols
; i
++)
3791 qsort (all_greg_symbols
[i
]->greg_fixes
, all_greg_symbols
[i
]->n_gregs
,
3792 sizeof (all_greg_symbols
[i
]->greg_fixes
[0]), cmp_greg_symbol_fixes
);
3794 if (real_reg_section
!= NULL
)
3796 /* FIXME: Pass error state gracefully. */
3797 if (bfd_get_section_flags (stdoutput
, real_reg_section
) & SEC_HAS_CONTENTS
)
3798 as_fatal (_("register section has contents\n"));
3800 bfd_section_list_remove (stdoutput
, real_reg_section
);
3801 --stdoutput
->section_count
;
3806 /* Provide an expression for a built-in name provided when-used.
3807 Either a symbol that is a handler; living in 0x10*[1..8] and having
3808 name [DVWIOUZX]_Handler, or a mmixal built-in symbol.
3810 If the name isn't a built-in name and parsed into *EXPP, return zero. */
3813 mmix_parse_predefined_name (char *name
, expressionS
*expP
)
3816 const char *handler_charp
;
3817 const char handler_chars
[] = "DVWIOUZX";
3820 if (! predefined_syms
)
3823 canon_name
= tc_canonicalize_symbol_name (name
);
3825 if (canon_name
[1] == '_'
3826 && strcmp (canon_name
+ 2, "Handler") == 0
3827 && (handler_charp
= strchr (handler_chars
, *canon_name
)) != NULL
)
3829 /* If the symbol doesn't exist, provide one relative to the .text
3832 FIXME: We should provide separate sections, mapped in the linker
3834 symp
= symbol_find (name
);
3836 symp
= symbol_new (name
, text_section
,
3837 0x10 * (handler_charp
+ 1 - handler_chars
),
3838 &zero_address_frag
);
3842 /* These symbols appear when referenced; needed for
3843 mmixal-compatible programs. */
3850 } predefined_abs_syms
[] =
3852 {"Data_Segment", (valueT
) 0x20 << 56},
3853 {"Pool_Segment", (valueT
) 0x40 << 56},
3854 {"Stack_Segment", (valueT
) 0x60 << 56},
3862 {"BinaryReadWrite", 4},
3885 /* If it's already in the symbol table, we shouldn't do anything. */
3886 symp
= symbol_find (name
);
3891 i
< sizeof (predefined_abs_syms
) / sizeof (predefined_abs_syms
[0]);
3893 if (strcmp (canon_name
, predefined_abs_syms
[i
].name
) == 0)
3895 symbol_table_insert (symbol_new (predefined_abs_syms
[i
].name
,
3897 predefined_abs_syms
[i
].val
,
3898 &zero_address_frag
));
3900 /* Let gas find the symbol we just created, through its
3905 /* Not one of those symbols. Let gas handle it. */
3909 expP
->X_op
= O_symbol
;
3910 expP
->X_add_number
= 0;
3911 expP
->X_add_symbol
= symp
;
3912 expP
->X_op_symbol
= NULL
;
3917 /* Just check that we don't have a BSPEC/ESPEC pair active when changing
3918 sections "normally", and get knowledge about alignment from the new
3922 mmix_md_elf_section_change_hook (void)
3925 as_bad (_("section change from within a BSPEC/ESPEC pair is not supported"));
3927 last_alignment
= bfd_get_section_alignment (now_seg
->owner
, now_seg
);
3931 /* The LOC worker. This is like s_org, but we have to support changing
3935 s_loc (int ignore ATTRIBUTE_UNUSED
)
3943 /* Must not have a BSPEC in progress. */
3946 as_bad (_("directive LOC from within a BSPEC/ESPEC pair is not supported"));
3950 section
= expression (&exp
);
3952 if (exp
.X_op
== O_illegal
3953 || exp
.X_op
== O_absent
3954 || exp
.X_op
== O_big
)
3956 as_bad (_("invalid LOC expression"));
3960 if (section
== undefined_section
)
3962 /* This is an error or a LOC with an expression involving
3963 forward references. For the expression to be correctly
3964 evaluated, we need to force a proper symbol; gas loses track
3965 of the segment for "local symbols". */
3966 if (exp
.X_op
== O_add
)
3968 symbol_get_value_expression (exp
.X_op_symbol
);
3969 symbol_get_value_expression (exp
.X_add_symbol
);
3973 gas_assert (exp
.X_op
== O_symbol
);
3974 symbol_get_value_expression (exp
.X_add_symbol
);
3978 if (section
== absolute_section
)
3980 /* Translate a constant into a suitable section. */
3982 if (exp
.X_add_number
< ((offsetT
) 0x20 << 56))
3984 /* Lower than Data_Segment or in the reserved area (the
3985 segment number is >= 0x80, appearing negative) - assume
3987 section
= text_section
;
3989 /* Save the lowest seen location, so we can pass on this
3990 information to the linker. We don't actually org to this
3991 location here, we just pass on information to the linker so
3992 it can put the code there for us. */
3994 /* If there was already a loc (that has to be set lower than
3995 this one), we org at (this - lower). There's an implicit
3996 "LOC 0" before any entered code. FIXME: handled by spurious
3997 settings of text_has_contents. */
3998 if (lowest_text_loc
!= (bfd_vma
) -1
3999 && (bfd_vma
) exp
.X_add_number
< lowest_text_loc
)
4001 as_bad (_("LOC expression stepping backwards is not supported"));
4002 exp
.X_op
= O_absent
;
4006 if (text_has_contents
&& lowest_text_loc
== (bfd_vma
) -1)
4007 lowest_text_loc
= 0;
4009 if (lowest_text_loc
== (bfd_vma
) -1)
4011 lowest_text_loc
= exp
.X_add_number
;
4013 /* We want only to change the section, not set an offset. */
4014 exp
.X_op
= O_absent
;
4017 exp
.X_add_number
-= lowest_text_loc
;
4022 /* Do the same for the .data section, except we don't have
4023 to worry about exp.X_add_number carrying a sign. */
4024 section
= data_section
;
4026 if (exp
.X_add_number
< (offsetT
) lowest_data_loc
)
4028 as_bad (_("LOC expression stepping backwards is not supported"));
4029 exp
.X_op
= O_absent
;
4033 if (data_has_contents
&& lowest_data_loc
== (bfd_vma
) -1)
4034 lowest_data_loc
= (bfd_vma
) 0x20 << 56;
4036 if (lowest_data_loc
== (bfd_vma
) -1)
4038 lowest_data_loc
= exp
.X_add_number
;
4040 /* We want only to change the section, not set an offset. */
4041 exp
.X_op
= O_absent
;
4044 exp
.X_add_number
-= lowest_data_loc
;
4049 /* If we can't deduce the section, it must be the current one.
4050 Below, we arrange to assert this. */
4051 if (section
!= now_seg
&& section
!= undefined_section
)
4053 obj_elf_section_change_hook ();
4054 subseg_set (section
, 0);
4056 /* Call our section change hooks using the official hook. */
4057 md_elf_section_change_hook ();
4060 if (exp
.X_op
!= O_absent
)
4062 symbolS
*esym
= NULL
;
4064 if (exp
.X_op
!= O_constant
&& exp
.X_op
!= O_symbol
)
4066 /* Handle complex expressions. */
4067 esym
= sym
= make_expr_symbol (&exp
);
4072 sym
= exp
.X_add_symbol
;
4073 off
= exp
.X_add_number
;
4075 if (section
== undefined_section
)
4077 /* We need an expr_symbol when tracking sections. In
4078 order to make this an expr_symbol with file and line
4079 tracked, we have to make the exp non-trivial; not an
4080 O_symbol with .X_add_number == 0. The constant part
4082 exp
.X_add_number
= 1;
4083 esym
= make_expr_symbol (&exp
);
4087 /* Track the LOC's where we couldn't deduce the section: assert
4088 that we weren't supposed to change section. */
4089 if (section
== undefined_section
)
4091 struct loc_assert_s
*next
= loc_asserts
;
4092 loc_asserts
= XNEW (struct loc_assert_s
);
4093 loc_asserts
->next
= next
;
4094 loc_asserts
->old_seg
= now_seg
;
4095 loc_asserts
->loc_sym
= esym
;
4096 loc_asserts
->frag
= frag_now
;
4099 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
4103 mmix_handle_rest_of_empty_line ();
4106 /* The BYTE worker. We have to support sequences of mixed "strings",
4107 numbers and other constant "first-pass" reducible expressions separated
4115 if (now_seg
== text_section
)
4116 text_has_contents
= 1;
4117 else if (now_seg
== data_section
)
4118 data_has_contents
= 1;
4123 switch (*input_line_pointer
)
4126 ++input_line_pointer
;
4127 while (is_a_char (c
= next_char_of_string ()))
4129 FRAG_APPEND_1_CHAR (c
);
4132 if (input_line_pointer
[-1] != '\"')
4134 /* We will only get here in rare cases involving #NO_APP,
4135 where the unterminated string is not recognized by the
4136 preformatting pass. */
4137 as_bad (_("unterminated string"));
4138 mmix_discard_rest_of_line ();
4146 segT expseg
= expression (&exp
);
4148 /* We have to allow special register names as constant numbers. */
4149 if ((expseg
!= absolute_section
&& expseg
!= reg_section
)
4150 || (exp
.X_op
!= O_constant
4151 && (exp
.X_op
!= O_register
4152 || exp
.X_add_number
<= 255)))
4154 as_bad (_("BYTE expression not a pure number"));
4155 mmix_discard_rest_of_line ();
4158 else if ((exp
.X_add_number
> 255 && exp
.X_op
!= O_register
)
4159 || exp
.X_add_number
< 0)
4161 /* Note that mmixal does not allow negative numbers in
4162 BYTE sequences, so neither should we. */
4163 as_bad (_("BYTE expression not in the range 0..255"));
4164 mmix_discard_rest_of_line ();
4168 FRAG_APPEND_1_CHAR (exp
.X_add_number
);
4174 c
= *input_line_pointer
++;
4178 input_line_pointer
--;
4180 if (mmix_gnu_syntax
)
4181 demand_empty_rest_of_line ();
4184 mmix_discard_rest_of_line ();
4185 /* Do like demand_empty_rest_of_line and step over the end-of-line
4187 input_line_pointer
++;
4190 /* Make sure we align for the next instruction. */
4194 /* Like cons_worker, but we have to ignore "naked comments", not barf on
4195 them. Implements WYDE, TETRA and OCTA. We're a little bit more
4196 lenient than mmix_byte but FIXME: they should eventually merge. */
4199 mmix_cons (int nbytes
)
4203 /* If we don't have any contents, then it's ok to have a specified start
4204 address that is not a multiple of the max data size. We will then
4205 align it as necessary when we get here. Otherwise, it's a fatal sin. */
4206 if (now_seg
== text_section
)
4208 if (lowest_text_loc
!= (bfd_vma
) -1
4209 && (lowest_text_loc
& (nbytes
- 1)) != 0)
4211 if (text_has_contents
)
4212 as_bad (_("data item with alignment larger than location"));
4213 else if (want_unaligned
)
4214 as_bad (_("unaligned data at an absolute location is not supported"));
4216 lowest_text_loc
&= ~((bfd_vma
) nbytes
- 1);
4217 lowest_text_loc
+= (bfd_vma
) nbytes
;
4220 text_has_contents
= 1;
4222 else if (now_seg
== data_section
)
4224 if (lowest_data_loc
!= (bfd_vma
) -1
4225 && (lowest_data_loc
& (nbytes
- 1)) != 0)
4227 if (data_has_contents
)
4228 as_bad (_("data item with alignment larger than location"));
4229 else if (want_unaligned
)
4230 as_bad (_("unaligned data at an absolute location is not supported"));
4232 lowest_data_loc
&= ~((bfd_vma
) nbytes
- 1);
4233 lowest_data_loc
+= (bfd_vma
) nbytes
;
4236 data_has_contents
= 1;
4239 /* Always align these unless asked not to (valid for the current pseudo). */
4240 if (! want_unaligned
)
4242 last_alignment
= nbytes
== 2 ? 1 : (nbytes
== 4 ? 2 : 3);
4243 frag_align (last_alignment
, 0, 0);
4244 record_alignment (now_seg
, last_alignment
);
4247 /* For mmixal compatibility, a label for an instruction (and emitting
4248 pseudo) refers to the _aligned_ address. So we have to emit the
4250 if (current_fb_label
>= 0)
4251 colon (fb_label_name (current_fb_label
, 1));
4252 else if (pending_label
!= NULL
)
4254 colon (pending_label
);
4255 pending_label
= NULL
;
4260 if (is_end_of_line
[(unsigned int) *input_line_pointer
])
4262 /* Default to zero if the expression was absent. */
4264 exp
.X_op
= O_constant
;
4265 exp
.X_add_number
= 0;
4267 exp
.X_add_symbol
= NULL
;
4268 exp
.X_op_symbol
= NULL
;
4269 emit_expr (&exp
, (unsigned int) nbytes
);
4276 switch (*input_line_pointer
)
4278 /* We support strings here too; each character takes up nbytes
4281 ++input_line_pointer
;
4282 while (is_a_char (c
= next_char_of_string ()))
4284 exp
.X_op
= O_constant
;
4285 exp
.X_add_number
= c
;
4287 emit_expr (&exp
, (unsigned int) nbytes
);
4290 if (input_line_pointer
[-1] != '\"')
4292 /* We will only get here in rare cases involving #NO_APP,
4293 where the unterminated string is not recognized by the
4294 preformatting pass. */
4295 as_bad (_("unterminated string"));
4296 mmix_discard_rest_of_line ();
4304 emit_expr (&exp
, (unsigned int) nbytes
);
4310 while (*input_line_pointer
++ == ',');
4312 input_line_pointer
--; /* Put terminator back into stream. */
4314 mmix_handle_rest_of_empty_line ();
4316 /* We don't need to step up the counter for the current_fb_label here;
4317 that's handled by the caller. */
4320 /* The md_do_align worker. At present, we just record an alignment to
4321 nullify the automatic alignment we do for WYDE, TETRA and OCTA, as gcc
4322 does not use the unaligned macros when attribute packed is used.
4323 Arguably this is a GCC bug. */
4326 mmix_md_do_align (int n
, char *fill ATTRIBUTE_UNUSED
,
4327 int len ATTRIBUTE_UNUSED
, int max ATTRIBUTE_UNUSED
)
4330 want_unaligned
= n
== 0;