1 /* tc-dlx.c -- Assemble for the DLX
2 Copyright (C) 2002-2021 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 the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* Initially created by Kuang Hwa Lin, 3/20/2002. */
24 #include "safe-ctype.h"
26 #include "opcode/dlx.h"
28 #include "bfd/elf32-dlx.h"
30 /* Make it easier to clone this machine desc into another one. */
31 #define machine_opcode dlx_opcode
32 #define machine_opcodes dlx_opcodes
33 #define machine_ip dlx_ip
34 #define machine_it dlx_it
36 #define NO_RELOC BFD_RELOC_NONE
37 #define RELOC_DLX_REL26 BFD_RELOC_DLX_JMP26
38 #define RELOC_DLX_16 BFD_RELOC_16
39 #define RELOC_DLX_REL16 BFD_RELOC_16_PCREL_S2
40 #define RELOC_DLX_HI16 BFD_RELOC_HI16_S
41 #define RELOC_DLX_LO16 BFD_RELOC_LO16
42 #define RELOC_DLX_VTINHERIT BFD_RELOC_VTABLE_INHERIT
43 #define RELOC_DLX_VTENTRY BFD_RELOC_VTABLE_ENTRY
45 /* handle of the OPCODE hash table */
46 static htab_t op_hash
= NULL
;
56 int reloc_offset
; /* Offset of reloc within insn. */
57 bfd_reloc_code_real_type reloc
;
63 /* This array holds the chars that always start a comment. If the
64 pre-processor is disabled, these aren't very useful. */
65 const char comment_chars
[] = ";";
67 /* This array holds the chars that only start a comment at the beginning of
68 a line. If the line seems to have the form '# 123 filename'
69 .line and .file directives will appear in the pre-processed output. */
70 /* Note that input_file.c hand checks for '#' at the beginning of the
71 first line of the input file. This is because the compiler outputs
72 #NO_APP at the beginning of its output. */
73 /* Also note that comments like this one will always work. */
74 const char line_comment_chars
[] = "#";
76 /* We needed an unused char for line separation to work around the
77 lack of macros, using sed and such. */
78 const char line_separator_chars
[] = "@";
80 /* Chars that can be used to separate mant from exp in floating point nums. */
81 const char EXP_CHARS
[] = "eE";
83 /* Chars that mean this number is a floating point constant.
86 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
89 insert_sreg (const char *regname
, int regnum
)
91 /* Must be large enough to hold the names of the special registers. */
95 symbol_table_insert (symbol_new (regname
, reg_section
,
96 &zero_address_frag
, regnum
));
97 for (i
= 0; regname
[i
]; i
++)
98 buf
[i
] = ISLOWER (regname
[i
]) ? TOUPPER (regname
[i
]) : regname
[i
];
101 symbol_table_insert (symbol_new (buf
, reg_section
,
102 &zero_address_frag
, regnum
));
105 /* Install symbol definitions for assorted special registers.
106 See MIPS Assembly Language Programmer's Guide page 1-4 */
109 define_some_regs (void)
111 /* Software representation. */
112 insert_sreg ("zero", 0);
113 insert_sreg ("at", 1);
114 insert_sreg ("v0", 2);
115 insert_sreg ("v1", 3);
116 insert_sreg ("a0", 4);
117 insert_sreg ("a1", 5);
118 insert_sreg ("a2", 6);
119 insert_sreg ("a3", 7);
120 insert_sreg ("t0", 8);
121 insert_sreg ("t1", 9);
122 insert_sreg ("t2", 10);
123 insert_sreg ("t3", 11);
124 insert_sreg ("t4", 12);
125 insert_sreg ("t5", 13);
126 insert_sreg ("t6", 14);
127 insert_sreg ("t7", 15);
128 insert_sreg ("s0", 16);
129 insert_sreg ("s1", 17);
130 insert_sreg ("s2", 18);
131 insert_sreg ("s3", 19);
132 insert_sreg ("s4", 20);
133 insert_sreg ("s5", 21);
134 insert_sreg ("s6", 22);
135 insert_sreg ("s7", 23);
136 insert_sreg ("t8", 24);
137 insert_sreg ("t9", 25);
138 insert_sreg ("k0", 26);
139 insert_sreg ("k1", 27);
140 insert_sreg ("gp", 28);
141 insert_sreg ("sp", 29);
142 insert_sreg ("fp", 30);
143 insert_sreg ("ra", 31);
144 /* Special registers. */
145 insert_sreg ("pc", 0);
146 insert_sreg ("npc", 1);
147 insert_sreg ("iad", 2);
150 /* Subroutine check the string to match an register. */
153 match_sft_register (char *name
)
155 #define MAX_REG_NO 35
156 /* Currently we have 35 software registers defined -
157 we borrowed from MIPS. */
158 static const char *soft_reg
[] =
160 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
161 "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "t8", "t9",
162 "s0", "s1", "s2", "s3", "s4", "s5", "s7", "k0", "k1",
163 "gp", "sp", "fp", "ra", "pc", "npc", "iad",
164 "EndofTab" /* End of the Table indicator */
166 char low_name
[21], *ptr
;
169 for (ptr
= name
,idx
= 0; *ptr
!= '\0'; ptr
++)
170 low_name
[idx
++] = TOLOWER (*ptr
);
172 low_name
[idx
] = '\0';
175 while (idx
< MAX_REG_NO
&& strcmp (soft_reg
[idx
], & low_name
[0]))
178 return idx
< MAX_REG_NO
;
181 /* Subroutine check the string to match an register. */
184 is_ldst_registers (char *name
)
188 /* The first character of the register name got to be either %, $, r of R. */
189 if ((ptr
[0] == '%' || ptr
[0] == '$' || ptr
[0] == 'r' || ptr
[0] == 'R')
190 && ISDIGIT ((unsigned char) ptr
[1]))
193 /* Now check the software register representation. */
194 return match_sft_register (ptr
);
197 /* Subroutine of s_proc so targets can choose a different default prefix.
198 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
203 /* Record the current function so that we can issue an error message for
204 misplaced .func,.endfunc, and also so that .endfunc needs no
206 static char *current_name
;
207 static char *current_label
;
211 if (current_name
== NULL
)
213 as_bad (_("missing .proc"));
214 ignore_rest_of_line ();
218 current_name
= current_label
= NULL
;
220 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
221 input_line_pointer
++;
228 if (current_name
!= NULL
)
230 as_bad (_(".endfunc missing for previous .proc"));
231 ignore_rest_of_line ();
235 delim1
= get_symbol_name (&name
);
236 name
= xstrdup (name
);
237 *input_line_pointer
= delim1
;
238 SKIP_WHITESPACE_AFTER_NAME ();
240 if (*input_line_pointer
!= ',')
242 char leading_char
= 0;
244 leading_char
= bfd_get_symbol_leading_char (stdoutput
);
245 /* Missing entry point, use function's name with the leading
249 unsigned len
= strlen (name
) + 1;
250 label
= XNEWVEC (char, len
+ 1);
251 label
[0] = leading_char
;
252 memcpy (label
+ 1, name
, len
);
259 ++input_line_pointer
;
261 delim2
= get_symbol_name (&label
);
262 label
= xstrdup (label
);
263 (void) restore_line_pointer (delim2
);
267 current_label
= label
;
269 demand_empty_rest_of_line ();
272 /* This function is called once, at assembler startup time. It should
273 set up all the tables, etc., that the MD part of the assembler will
281 /* Create a new hash table. */
282 op_hash
= str_htab_create ();
284 /* Hash up all the opcodes for fast use later. */
285 for (i
= 0; i
< num_dlx_opcodes
; i
++)
287 const char *name
= machine_opcodes
[i
].name
;
288 if (str_hash_insert (op_hash
, name
, &machine_opcodes
[i
], 0) != NULL
)
289 as_fatal (_("duplicate %s"), name
);
295 /* This function will check the opcode and return 1 if the opcode is one
296 of the load/store instruction, and it will fix the operand string to
297 the standard form so we can use the standard parse_operand routine. */
299 #define READ_OP 0x100
300 #define WRITE_OP 0x200
301 static char iBuf
[81];
304 dlx_parse_loadop (char * str
)
309 /* The last pair of ()/[] is the register, all other are the
310 reloc displacement, and if there is a register then it ought
311 to have a pair of ()/[]
312 This is not necessarily true, what if the load instruction come
313 without the register and with %hi/%lo modifier? */
314 for (idx
= 0; idx
< 72 && ptr
[idx
] != '\0'; idx
++)
320 as_bad (_("Bad operand for a load instruction: <%s>"), str
);
327 char rs1
[7], rd
[7], endm
, match
= '0';
342 /* No register indicated, fill in zero. */
353 /* Searching for (/[ which will match the ]/). */
354 for (pb
= idx
- 1; str
[pb
] != match
; pb
-= 1)
355 /* Match can only be either '[' or '(', if it is
356 '(' then this can be a normal expression, we'll treat
358 if (str
[pb
] == endm
|| pb
< (idx
- 5))
362 for (i
= 0; (pb
+ i
) < idx
; i
++)
367 if (is_ldst_registers (& rs1
[0]))
368 /* Point to the last character of the imm. */
374 goto badoperand_load
;
375 /* No register indicated, fill in zero and restore the imm. */
383 /* Duplicate the first register. */
384 for (i
= 0; i
< 7 && str
[i
] != ','; i
++)
388 goto badoperand_load
;
394 /* Put the '\0' back in. */
397 for (i
++, m2
= 0; i
< pb
; m2
++,i
++)
402 /* Assemble the instruction to gas internal format. */
403 for (i
= 0; rd
[i
] != '\0'; i
++)
408 for (pb
= 0 ; rs1
[pb
] != '\0'; i
++, pb
++)
413 for (pb
= 0; imm
[pb
] != '\0'; i
++, pb
++)
422 dlx_parse_storeop (char * str
)
427 /* Search for the ','. */
428 for (idx
= 0; idx
< 72 && ptr
[idx
] != ','; idx
++)
434 as_bad (_("Bad operand for a store instruction: <%s>"), str
);
439 /* idx now points to the ','. */
443 char rs1
[7], rd
[7], endm
, match
= '0';
446 /* Now parse the '(' and ')', and make idx point to ')'. */
459 /* No register indicated, fill in zero. */
470 /* Searching for (/[ which will match the ]/). */
471 for (pb
= idx
- 1; str
[pb
] != match
; pb
-= 1)
472 if (pb
< (idx
- 5) || str
[pb
] == endm
)
476 for (i
= 0; (pb
+ i
) < idx
; i
++)
477 rs1
[i
] = str
[pb
+ i
];
481 if (is_ldst_registers (& rs1
[0]))
482 /* Point to the last character of the imm. */
488 goto badoperand_store
;
490 /* No register indicated, fill in zero and restore the imm. */
498 /* No register was specified. */
501 /* Duplicate the first register. */
502 for (i
= comma
+ 1; (str
[i
] == ' ' || str
[i
] == '\t'); i
++)
505 for (m2
= 0; (m2
< 7 && str
[i
] != '\0'); i
++, m2
++)
507 if (str
[i
] != ' ' && str
[i
] != '\t')
510 goto badoperand_store
;
514 goto badoperand_store
;
519 for (i
= 0; i
< pb
; i
++)
524 /* Assemble the instruction to gas internal format. */
525 for (i
= 0; rd
[i
] != '\0'; i
++)
528 for (pb
= 0 ; rs1
[pb
] != '\0'; i
++, pb
++)
531 for (pb
= 0; imm
[pb
] != '\0'; i
++, pb
++)
539 fix_ld_st_operand (unsigned long opcode
, char* str
)
541 /* Check the opcode. */
542 switch ((int) opcode
)
552 return dlx_parse_loadop (str
);
556 return dlx_parse_storeop (str
);
563 hilo_modifier_ok (char *s
)
571 for (idx
= 1; ptr
[idx
] != '\0' && ptr
[idx
] != '[' && idx
< 73; idx
+= 1)
583 return (count
== 0) ? 1:0;
587 parse_operand (char *s
, expressionS
*operandp
)
589 char *save
= input_line_pointer
;
592 the_insn
.HI
= the_insn
.LO
= 0;
594 /* Search for %hi and %lo, make a mark and skip it. */
595 if (strncmp (s
, "%hi", 3) == 0)
602 if (strncmp (s
, "%lo", 3) == 0)
611 if (the_insn
.HI
|| the_insn
.LO
)
613 if (!hilo_modifier_ok (s
))
614 as_bad (_("Expression Error for operand modifier %%hi/%%lo\n"));
617 /* Check for the % and $ register representation */
618 if ((s
[0] == '%' || s
[0] == '$' || s
[0] == 'r' || s
[0] == 'R')
619 && ISDIGIT ((unsigned char) s
[1]))
621 /* We have a numeric register expression. No biggy. */
623 input_line_pointer
= s
;
624 (void) expression (operandp
);
625 if (operandp
->X_op
!= O_constant
626 || operandp
->X_add_number
> 31)
627 as_bad (_("Invalid expression after %%%%\n"));
628 operandp
->X_op
= O_register
;
632 /* Normal operand parsing. */
633 input_line_pointer
= s
;
634 (void) expression (operandp
);
637 new_pos
= input_line_pointer
;
638 input_line_pointer
= save
;
642 /* Instruction parsing. Takes a string containing the opcode.
643 Operands are at input_line_pointer. Output is in the_insn.
644 Warnings or errors are generated. */
647 machine_ip (char *str
)
651 struct machine_opcode
*insn
;
652 unsigned long opcode
;
653 expressionS the_operand
;
654 expressionS
*operand
= &the_operand
;
655 unsigned int reg
, reg_shift
= 0;
657 memset (&the_insn
, '\0', sizeof (the_insn
));
658 the_insn
.reloc
= NO_RELOC
;
660 /* Fixup the opcode string to all lower cases, and also
661 allow numerical digits. */
665 for (; ISALNUM (*s
); ++s
)
674 /* FIXME-SOMEDAY more whitespace. */
680 as_bad (_("Unknown opcode: `%s'"), str
);
684 /* Hash the opcode, insn will have the string from opcode table. */
685 if ((insn
= (struct machine_opcode
*) str_hash_find (op_hash
, str
)) == NULL
)
687 /* Handle the ret and return macro here. */
688 if ((strcmp (str
, "ret") == 0) || (strcmp (str
, "return") == 0))
689 the_insn
.opcode
= JROP
| 0x03e00000; /* 0x03e00000 = r31 << 21 */
691 as_bad (_("Unknown opcode `%s'."), str
);
696 opcode
= insn
->opcode
;
698 /* Set the sip reloc HI16 flag. */
699 if (!set_dlx_skip_hi16_flag (1))
700 as_bad (_("Can not set dlx_skip_hi16_flag"));
702 /* Fix the operand string if it is one of load store instructions. */
703 s
= fix_ld_st_operand (opcode
, s
);
705 /* Build the opcode, checking as we go to make sure that the
707 If an operand matches, we modify the_insn or opcode appropriately,
708 and do a "continue". If an operand fails to match, we "break". */
709 if (insn
->args
[0] != '\0' && insn
->args
[0] != 'N')
711 /* Prime the pump. */
714 as_bad (_("Missing arguments for opcode <%s>."), str
);
718 s
= parse_operand (s
, operand
);
720 else if (insn
->args
[0] == 'N')
722 /* Clean up the insn and done! */
723 the_insn
.opcode
= opcode
;
727 /* Parse through the args (this is from opcode table), *s point to
728 the current character of the instruction stream. */
729 for (args
= insn
->args
;; ++args
)
738 /* We are truly done. */
739 the_insn
.opcode
= opcode
;
740 /* Clean up the HI and LO mark. */
748 as_bad (_("Too many operands: %s"), s
);
751 /* ',' Args separator */
753 /* Must match a comma. */
756 /* Parse next operand. */
757 s
= parse_operand (s
, operand
);
762 /* It can be a 'a' register or 'i' operand. */
764 /* Macro move operand/reg. */
765 if (operand
->X_op
== O_register
)
767 /* It's a register. */
773 /* The immediate 16 bits literal, bit 0-15. */
775 /* offset, unsigned. */
777 /* offset, signed. */
778 if (operand
->X_op
== O_constant
)
781 operand
->X_add_number
>>= 16;
783 opcode
|= operand
->X_add_number
& 0xFFFF;
785 if (the_insn
.HI
&& the_insn
.LO
)
786 as_bad (_("Both the_insn.HI and the_insn.LO are set : %s"), s
);
795 the_insn
.reloc
= (the_insn
.HI
) ? RELOC_DLX_HI16
796 : (the_insn
.LO
? RELOC_DLX_LO16
: RELOC_DLX_16
);
797 the_insn
.reloc_offset
= 2;
800 the_insn
.exp
= * operand
;
806 /* offset, signed. */
807 if (operand
->X_op
== O_constant
)
809 opcode
|= operand
->X_add_number
& 0xFFFF;
812 the_insn
.reloc
= RELOC_DLX_REL16
;
813 the_insn
.reloc_offset
= 0; /* BIG-ENDIAN Byte 3 of insn. */
816 the_insn
.exp
= *operand
;
819 /* The immediate 26 bits literal, bit 0-25. */
821 /* offset, signed. */
822 if (operand
->X_op
== O_constant
)
824 opcode
|= operand
->X_add_number
& 0x3FFFFFF;
827 the_insn
.reloc
= RELOC_DLX_REL26
;
828 the_insn
.reloc_offset
= 0; /* BIG-ENDIAN Byte 3 of insn. */
831 the_insn
.exp
= *operand
;
834 /* Type 'a' Register. */
836 /* A general register at bits 21-25, rs1. */
840 /* Type 'b' Register. */
842 /* A general register at bits 16-20, rs2/rd. */
846 /* Type 'c' Register. */
848 /* A general register at bits 11-15, rd. */
852 know (operand
->X_add_symbol
== 0);
853 know (operand
->X_op_symbol
== 0);
854 reg
= operand
->X_add_number
;
855 if (reg
& 0xffffffe0)
856 as_fatal (_("failed regnum sanity check."));
858 /* Got the register, now figure out where it goes in the opcode. */
859 opcode
|= reg
<< reg_shift
;
869 as_fatal (_("failed general register sanity check."));
876 /* Types or values of args don't match. */
877 as_bad (_("Invalid operands"));
882 /* Assemble a single instruction. Its label has already been handled
883 by the generic front end. We just parse opcode and operands, and
884 produce the bytes of data and relocation. */
887 md_assemble (char *str
)
896 dwarf2_emit_insn (4);
898 /* Put out the opcode. */
899 md_number_to_chars (toP
, the_insn
.opcode
, 4);
901 /* Put out the symbol-dependent stuff. */
902 if (the_insn
.reloc
!= NO_RELOC
)
904 fixP
= fix_new_exp (frag_now
,
905 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
),
906 the_insn
.size
, & the_insn
.exp
, the_insn
.pcrel
,
909 /* Turn off complaints that the addend is
910 too large for things like foo+100000@ha. */
911 switch (the_insn
.reloc
)
915 fixP
->fx_no_overflow
= 1;
921 switch (fixP
->fx_r_type
)
923 case RELOC_DLX_REL26
:
924 bitP
= XNEW (bit_fixS
);
925 bitP
->fx_bit_size
= 26;
926 bitP
->fx_bit_offset
= 25;
927 bitP
->fx_bit_base
= the_insn
.opcode
& 0xFC000000;
928 bitP
->fx_bit_base_adj
= 0;
929 bitP
->fx_bit_max
= 0;
930 bitP
->fx_bit_min
= 0;
931 bitP
->fx_bit_add
= 0x03FFFFFF;
932 fixP
->fx_bit_fixP
= bitP
;
935 case RELOC_DLX_REL16
:
936 bitP
= XNEW (bit_fixS
);
937 bitP
->fx_bit_size
= 16;
938 bitP
->fx_bit_offset
= 15;
939 bitP
->fx_bit_base
= the_insn
.opcode
& 0xFFFF0000;
940 bitP
->fx_bit_base_adj
= 0;
941 bitP
->fx_bit_max
= 0;
942 bitP
->fx_bit_min
= 0;
943 bitP
->fx_bit_add
= 0x0000FFFF;
944 fixP
->fx_bit_fixP
= bitP
;
947 bitP
= XNEW (bit_fixS
);
948 bitP
->fx_bit_size
= 16;
949 bitP
->fx_bit_offset
= 15;
950 bitP
->fx_bit_base
= the_insn
.opcode
& 0xFFFF0000;
951 bitP
->fx_bit_base_adj
= 0;
952 bitP
->fx_bit_max
= 0;
953 bitP
->fx_bit_min
= 0;
954 bitP
->fx_bit_add
= 0x0000FFFF;
955 fixP
->fx_bit_fixP
= bitP
;
958 fixP
->fx_bit_fixP
= NULL
;
964 /* This is identical to the md_atof in m68k.c. I think this is right,
965 but I'm not sure. Dlx will not use it anyway, so I just leave it
969 md_atof (int type
, char *litP
, int *sizeP
)
971 return ieee_md_atof (type
, litP
, sizeP
, TRUE
);
974 /* Write out big-endian. */
976 md_number_to_chars (char *buf
, valueT val
, int n
)
978 number_to_chars_bigendian (buf
, val
, n
);
982 md_dlx_fix_adjustable (fixS
*fixP
)
984 /* We need the symbol name for the VTABLE entries. */
985 return (fixP
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
986 && fixP
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
);
990 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
993 char *place
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
995 switch (fixP
->fx_r_type
)
998 case RELOC_DLX_REL16
:
999 if (fixP
->fx_bit_fixP
!= NULL
)
1001 val
= (val
& 0x0000FFFF) | fixP
->fx_bit_fixP
->fx_bit_base
;
1002 free (fixP
->fx_bit_fixP
);
1003 fixP
->fx_bit_fixP
= NULL
;
1007 case RELOC_DLX_HI16
:
1008 if (fixP
->fx_bit_fixP
!= NULL
)
1010 val
= (val
>> 16) | fixP
->fx_bit_fixP
->fx_bit_base
;
1011 free (fixP
->fx_bit_fixP
);
1012 fixP
->fx_bit_fixP
= NULL
;
1016 case RELOC_DLX_REL26
:
1017 if (fixP
->fx_bit_fixP
!= NULL
)
1019 val
= (val
& 0x03FFFFFF) | fixP
->fx_bit_fixP
->fx_bit_base
;
1020 free (fixP
->fx_bit_fixP
);
1021 fixP
->fx_bit_fixP
= NULL
;
1025 case BFD_RELOC_VTABLE_INHERIT
:
1026 /* This borrowed from tc-ppc.c on a whim. */
1029 && !S_IS_DEFINED (fixP
->fx_addsy
)
1030 && !S_IS_WEAK (fixP
->fx_addsy
))
1031 S_SET_WEAK (fixP
->fx_addsy
);
1034 case BFD_RELOC_VTABLE_ENTRY
:
1042 number_to_chars_bigendian (place
, val
, fixP
->fx_size
);
1043 if (fixP
->fx_addsy
== NULL
)
1045 if (fixP
->fx_bit_fixP
!= NULL
)
1046 fixP
->fx_no_overflow
= 1;
1049 const char *md_shortopts
= "";
1051 struct option md_longopts
[] =
1053 {NULL
, no_argument
, NULL
, 0}
1056 size_t md_longopts_size
= sizeof (md_longopts
);
1059 md_parse_option (int c ATTRIBUTE_UNUSED
,
1060 const char *arg ATTRIBUTE_UNUSED
)
1066 md_show_usage (FILE *stream ATTRIBUTE_UNUSED
)
1070 /* This is called when a line is unrecognized. */
1073 dlx_unrecognized_line (int c
)
1078 if (c
!= '$' || ! ISDIGIT ((unsigned char) input_line_pointer
[0]))
1081 s
= input_line_pointer
;
1084 while (ISDIGIT ((unsigned char) *s
))
1086 lab
= lab
* 10 + *s
- '0';
1091 /* Not a label definition. */
1094 if (dollar_label_defined (lab
))
1096 as_bad (_("label \"$%d\" redefined"), lab
);
1100 define_dollar_label (lab
);
1101 colon (dollar_label_name (lab
, 0));
1102 input_line_pointer
= s
+ 1;
1107 /* Default the values of symbols known that should be "predefined". We
1108 don't bother to predefine them unless you actually use one, since there
1109 are a lot of them. */
1112 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
1117 /* Parse an operand that is machine-specific, the function was called
1118 in expr.c by operand() function, when everything failed before it
1122 md_operand (expressionS
* expressionP
)
1124 /* Check for the #number representation */
1125 if (input_line_pointer
[0] == '#' &&
1126 ISDIGIT ((unsigned char) input_line_pointer
[1]))
1128 /* We have a numeric number expression. No biggy. */
1129 input_line_pointer
+= 1; /* Skip # */
1131 (void) expression (expressionP
);
1133 if (expressionP
->X_op
!= O_constant
)
1134 as_bad (_("Invalid expression after # number\n"));
1140 /* Round up a section size to the appropriate boundary. */
1143 md_section_align (segT segment ATTRIBUTE_UNUSED
,
1146 /* Byte alignment is fine. */
1150 /* Exactly what point is a PC-relative offset relative TO?
1151 On the 29000, they're relative to the address of the instruction,
1152 which we have set up as the address of the fixup too. */
1155 md_pcrel_from (fixS
* fixP
)
1157 return 4 + fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1160 /* Translate internal representation of relocation info to BFD target
1162 FIXME: To what extent can we get all relevant targets to use this?
1163 The above FIXME is from a29k, but I think it is also needed here. */
1166 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
,
1171 reloc
= XNEW (arelent
);
1172 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
1174 if (reloc
->howto
== NULL
)
1176 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1177 _("internal error: can't export reloc type %d (`%s')"),
1179 bfd_get_reloc_code_name (fixP
->fx_r_type
));
1183 gas_assert (!fixP
->fx_pcrel
== !reloc
->howto
->pc_relative
);
1185 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
1186 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixP
->fx_addsy
);
1187 reloc
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1189 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1190 reloc
->address
= fixP
->fx_offset
;
1197 dlx_pseudo_table
[] =
1199 /* Some additional ops that are used by gcc-dlx. */
1200 {"asciiz", stringer
, 8 + 1},
1204 {"proc", s_proc
, 0},
1205 {"endproc", s_proc
, 1},
1210 dlx_pop_insert (void)
1212 pop_insert (dlx_pseudo_table
);