1 /* tc-dlx.c -- Assemble for the DLX
2 Copyright 2002, 2003, 2004, 2005, 2007, 2009, 2010, 2012
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Initially created by Kuang Hwa Lin, 3/20/2002. */
25 #include "safe-ctype.h"
27 #include "opcode/dlx.h"
29 /* Make it easier to clone this machine desc into another one. */
30 #define machine_opcode dlx_opcode
31 #define machine_opcodes dlx_opcodes
32 #define machine_ip dlx_ip
33 #define machine_it dlx_it
35 #define NO_RELOC BFD_RELOC_NONE
36 #define RELOC_DLX_REL26 BFD_RELOC_DLX_JMP26
37 #define RELOC_DLX_16 BFD_RELOC_16
38 #define RELOC_DLX_REL16 BFD_RELOC_16_PCREL_S2
39 #define RELOC_DLX_HI16 BFD_RELOC_HI16_S
40 #define RELOC_DLX_LO16 BFD_RELOC_LO16
41 #define RELOC_DLX_VTINHERIT BFD_RELOC_VTABLE_INHERIT
42 #define RELOC_DLX_VTENTRY BFD_RELOC_VTABLE_ENTRY
44 /* handle of the OPCODE hash table */
45 static struct hash_control
*op_hash
= NULL
;
55 int reloc_offset
; /* Offset of reloc within insn. */
62 /* This array holds the chars that always start a comment. If the
63 pre-processor is disabled, these aren't very useful. */
64 const char comment_chars
[] = ";";
66 /* This array holds the chars that only start a comment at the beginning of
67 a line. If the line seems to have the form '# 123 filename'
68 .line and .file directives will appear in the pre-processed output. */
69 /* Note that input_file.c hand checks for '#' at the beginning of the
70 first line of the input file. This is because the compiler outputs
71 #NO_APP at the beginning of its output. */
72 /* Also note that comments like this one will always work. */
73 const char line_comment_chars
[] = "#";
75 /* We needed an unused char for line separation to work around the
76 lack of macros, using sed and such. */
77 const char line_separator_chars
[] = "@";
79 /* Chars that can be used to separate mant from exp in floating point nums. */
80 const char EXP_CHARS
[] = "eE";
82 /* Chars that mean this number is a floating point constant.
85 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
88 insert_sreg (char *regname
, int regnum
)
90 /* Must be large enough to hold the names of the special registers. */
94 symbol_table_insert (symbol_new (regname
, reg_section
, (valueT
) regnum
,
96 for (i
= 0; regname
[i
]; i
++)
97 buf
[i
] = ISLOWER (regname
[i
]) ? TOUPPER (regname
[i
]) : regname
[i
];
100 symbol_table_insert (symbol_new (buf
, reg_section
, (valueT
) regnum
,
101 &zero_address_frag
));
104 /* Install symbol definitions for assorted special registers.
105 See MIPS Assembly Language Programmer's Guide page 1-4 */
108 define_some_regs (void)
110 /* Software representation. */
111 insert_sreg ("zero", 0);
112 insert_sreg ("at", 1);
113 insert_sreg ("v0", 2);
114 insert_sreg ("v1", 3);
115 insert_sreg ("a0", 4);
116 insert_sreg ("a1", 5);
117 insert_sreg ("a2", 6);
118 insert_sreg ("a3", 7);
119 insert_sreg ("t0", 8);
120 insert_sreg ("t1", 9);
121 insert_sreg ("t2", 10);
122 insert_sreg ("t3", 11);
123 insert_sreg ("t4", 12);
124 insert_sreg ("t5", 13);
125 insert_sreg ("t6", 14);
126 insert_sreg ("t7", 15);
127 insert_sreg ("s0", 16);
128 insert_sreg ("s1", 17);
129 insert_sreg ("s2", 18);
130 insert_sreg ("s3", 19);
131 insert_sreg ("s4", 20);
132 insert_sreg ("s5", 21);
133 insert_sreg ("s6", 22);
134 insert_sreg ("s7", 23);
135 insert_sreg ("t8", 24);
136 insert_sreg ("t9", 25);
137 insert_sreg ("k0", 26);
138 insert_sreg ("k1", 27);
139 insert_sreg ("gp", 28);
140 insert_sreg ("sp", 29);
141 insert_sreg ("fp", 30);
142 insert_sreg ("ra", 31);
143 /* Special registers. */
144 insert_sreg ("pc", 0);
145 insert_sreg ("npc", 1);
146 insert_sreg ("iad", 2);
149 /* Subroutine check the string to match an register. */
152 match_sft_register (char *name
)
154 #define MAX_REG_NO 35
155 /* Currently we have 35 software registers defined -
156 we borrowed from MIPS. */
157 static char *soft_reg
[] =
159 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
160 "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "t8", "t9",
161 "s0", "s1", "s2", "s3", "s4", "s5", "s7", "k0", "k1",
162 "gp", "sp", "fp", "ra", "pc", "npc", "iad",
163 "EndofTab" /* End of the Table indicator */
165 char low_name
[21], *ptr
;
168 for (ptr
= name
,idx
= 0; *ptr
!= '\0'; ptr
++)
169 low_name
[idx
++] = TOLOWER (*ptr
);
171 low_name
[idx
] = '\0';
174 while (idx
< MAX_REG_NO
&& strcmp (soft_reg
[idx
], & low_name
[0]))
177 return idx
< MAX_REG_NO
;
180 /* Subroutine check the string to match an register. */
183 is_ldst_registers (char *name
)
187 /* The first character of the register name got to be either %, $, r of R. */
188 if ((ptr
[0] == '%' || ptr
[0] == '$' || ptr
[0] == 'r' || ptr
[0] == 'R')
189 && ISDIGIT ((unsigned char) ptr
[1]))
192 /* Now check the software register representation. */
193 return match_sft_register (ptr
);
196 /* Subroutine of s_proc so targets can choose a different default prefix.
197 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
202 /* Record the current function so that we can issue an error message for
203 misplaced .func,.endfunc, and also so that .endfunc needs no
205 static char *current_name
;
206 static char *current_label
;
210 if (current_name
== NULL
)
212 as_bad (_("missing .proc"));
213 ignore_rest_of_line ();
217 current_name
= current_label
= NULL
;
219 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
220 input_line_pointer
++;
227 if (current_name
!= NULL
)
229 as_bad (_(".endfunc missing for previous .proc"));
230 ignore_rest_of_line ();
234 name
= input_line_pointer
;
235 delim1
= get_symbol_end ();
236 name
= xstrdup (name
);
237 *input_line_pointer
= delim1
;
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
= xmalloc (len
+ 1);
251 label
[0] = leading_char
;
252 memcpy (label
+ 1, name
, len
);
259 ++input_line_pointer
;
261 label
= input_line_pointer
;
262 delim2
= get_symbol_end ();
263 label
= xstrdup (label
);
264 *input_line_pointer
= delim2
;
268 current_label
= label
;
270 demand_empty_rest_of_line ();
273 /* This function is called once, at assembler startup time. It should
274 set up all the tables, etc., that the MD part of the assembler will
280 const char *retval
= NULL
;
284 /* Create a new hash table. */
285 op_hash
= hash_new ();
287 /* Hash up all the opcodes for fast use later. */
288 for (i
= 0; i
< num_dlx_opcodes
; i
++)
290 const char *name
= machine_opcodes
[i
].name
;
292 retval
= hash_insert (op_hash
, name
, (void *) &machine_opcodes
[i
]);
296 fprintf (stderr
, _("internal error: can't hash `%s': %s\n"),
297 machine_opcodes
[i
].name
, retval
);
303 as_fatal (_("Broken assembler. No assembly attempted."));
308 /* This function will check the opcode and return 1 if the opcode is one
309 of the load/store instruction, and it will fix the operand string to
310 the standard form so we can use the standard parse_operand routine. */
312 #define READ_OP 0x100
313 #define WRITE_OP 0x200
314 static char iBuf
[81];
317 dlx_parse_loadop (char * str
)
322 /* The last pair of ()/[] is the register, all other are the
323 reloc displacement, and if there is a register then it ought
324 to have a pair of ()/[]
325 This is not necessarily true, what if the load instruction come
326 without the register and with %hi/%lo modifier? */
327 for (idx
= 0; idx
< 72 && ptr
[idx
] != '\0'; idx
++)
333 as_bad (_("Bad operand for a load instruction: <%s>"), str
);
340 char rs1
[7], rd
[7], endm
, match
= '0';
355 /* No register indicated, fill in zero. */
366 /* Searching for (/[ which will match the ]/). */
367 for (pb
= idx
- 1; str
[pb
] != match
; pb
-= 1)
368 /* Match can only be either '[' or '(', if it is
369 '(' then this can be a normal expression, we'll treat
371 if (str
[pb
] == endm
|| pb
< (idx
- 5))
375 for (i
= 0; (pb
+ i
) < idx
; i
++)
380 if (is_ldst_registers (& rs1
[0]))
381 /* Point to the last character of the imm. */
387 goto badoperand_load
;
388 /* No register indicated, fill in zero and restore the imm. */
396 /* Duplicate the first register. */
397 for (i
= 0; i
< 7 && str
[i
] != ','; i
++)
401 goto badoperand_load
;
407 /* Put the '\0' back in. */
410 for (i
++, m2
= 0; i
< pb
; m2
++,i
++)
415 /* Assemble the instruction to gas internal format. */
416 for (i
= 0; rd
[i
] != '\0'; i
++)
421 for (pb
= 0 ; rs1
[pb
] != '\0'; i
++, pb
++)
426 for (pb
= 0; imm
[pb
] != '\0'; i
++, pb
++)
435 dlx_parse_storeop (char * str
)
440 /* Search for the ','. */
441 for (idx
= 0; idx
< 72 && ptr
[idx
] != ','; idx
++)
447 as_bad (_("Bad operand for a store instruction: <%s>"), str
);
452 /* idx now points to the ','. */
456 char rs1
[7], rd
[7], endm
, match
= '0';
459 /* Now parse the '(' and ')', and make idx point to ')'. */
472 /* No register indicated, fill in zero. */
483 /* Searching for (/[ which will match the ]/). */
484 for (pb
= idx
- 1; str
[pb
] != match
; pb
-= 1)
485 if (pb
< (idx
- 5) || str
[pb
] == endm
)
489 for (i
= 0; (pb
+ i
) < idx
; i
++)
490 rs1
[i
] = str
[pb
+ i
];
494 if (is_ldst_registers (& rs1
[0]))
495 /* Point to the last character of the imm. */
501 goto badoperand_store
;
503 /* No register indicated, fill in zero and restore the imm. */
511 /* No register was specified. */
514 /* Duplicate the first register. */
515 for (i
= comma
+ 1; (str
[i
] == ' ' || str
[i
] == '\t'); i
++)
518 for (m2
= 0; (m2
< 7 && str
[i
] != '\0'); i
++, m2
++)
520 if (str
[i
] != ' ' && str
[i
] != '\t')
523 goto badoperand_store
;
527 goto badoperand_store
;
532 for (i
= 0; i
< pb
; i
++)
537 /* Assemble the instruction to gas internal format. */
538 for (i
= 0; rd
[i
] != '\0'; i
++)
541 for (pb
= 0 ; rs1
[pb
] != '\0'; i
++, pb
++)
544 for (pb
= 0; imm
[pb
] != '\0'; i
++, pb
++)
552 fix_ld_st_operand (unsigned long opcode
, char* str
)
554 /* Check the opcode. */
555 switch ((int) opcode
)
565 return dlx_parse_loadop (str
);
569 return dlx_parse_storeop (str
);
576 hilo_modifier_ok (char *s
)
584 for (idx
= 1; ptr
[idx
] != '\0' && ptr
[idx
] != '[' && idx
< 73; idx
+= 1)
596 return (count
== 0) ? 1:0;
600 parse_operand (char *s
, expressionS
*operandp
)
602 char *save
= input_line_pointer
;
605 the_insn
.HI
= the_insn
.LO
= 0;
607 /* Search for %hi and %lo, make a mark and skip it. */
608 if (strncmp (s
, "%hi", 3) == 0)
615 if (strncmp (s
, "%lo", 3) == 0)
624 if (the_insn
.HI
|| the_insn
.LO
)
626 if (!hilo_modifier_ok (s
))
627 as_bad (_("Expression Error for operand modifier %%hi/%%lo\n"));
630 /* Check for the % and $ register representation */
631 if ((s
[0] == '%' || s
[0] == '$' || s
[0] == 'r' || s
[0] == 'R')
632 && ISDIGIT ((unsigned char) s
[1]))
634 /* We have a numeric register expression. No biggy. */
636 input_line_pointer
= s
;
637 (void) expression (operandp
);
638 if (operandp
->X_op
!= O_constant
639 || operandp
->X_add_number
> 31)
640 as_bad (_("Invalid expression after %%%%\n"));
641 operandp
->X_op
= O_register
;
645 /* Normal operand parsing. */
646 input_line_pointer
= s
;
647 (void) expression (operandp
);
650 new_pos
= input_line_pointer
;
651 input_line_pointer
= save
;
655 /* Instruction parsing. Takes a string containing the opcode.
656 Operands are at input_line_pointer. Output is in the_insn.
657 Warnings or errors are generated. */
660 machine_ip (char *str
)
664 struct machine_opcode
*insn
;
665 unsigned long opcode
;
666 expressionS the_operand
;
667 expressionS
*operand
= &the_operand
;
668 unsigned int reg
, reg_shift
= 0;
670 /* Fixup the opcode string to all lower cases, and also
671 allow numerical digits. */
675 for (; ISALNUM (*s
); ++s
)
684 /* FIXME-SOMEDAY more whitespace. */
690 as_bad (_("Unknown opcode: `%s'"), str
);
694 /* Hash the opcode, insn will have the string from opcode table.
695 also initialized the_insn struct. */
696 if ((insn
= (struct machine_opcode
*) hash_find (op_hash
, str
)) == NULL
)
698 /* Handle the ret and return macro here. */
699 if ((strcmp (str
, "ret") == 0) || (strcmp (str
, "return") == 0))
701 memset (&the_insn
, '\0', sizeof (the_insn
));
702 the_insn
.reloc
= NO_RELOC
;
705 (unsigned long)(JROP
| 0x03e00000); /* 0x03e00000 = r31 << 21 */
708 as_bad (_("Unknown opcode `%s'."), str
);
713 opcode
= insn
->opcode
;
714 memset (&the_insn
, '\0', sizeof (the_insn
));
715 the_insn
.reloc
= NO_RELOC
;
718 /* Set the sip reloc HI16 flag. */
719 if (!set_dlx_skip_hi16_flag (1))
720 as_bad (_("Can not set dlx_skip_hi16_flag"));
722 /* Fix the operand string if it is one of load store instructions. */
723 s
= fix_ld_st_operand (opcode
, s
);
725 /* Build the opcode, checking as we go to make sure that the
727 If an operand matches, we modify the_insn or opcode appropriately,
728 and do a "continue". If an operand fails to match, we "break". */
729 if (insn
->args
[0] != '\0' && insn
->args
[0] != 'N')
731 /* Prime the pump. */
734 as_bad (_("Missing arguments for opcode <%s>."), str
);
738 s
= parse_operand (s
, operand
);
740 else if (insn
->args
[0] == 'N')
742 /* Clean up the insn and done! */
743 the_insn
.opcode
= opcode
;
747 /* Parse through the args (this is from opcode table), *s point to
748 the current character of the instruction stream. */
749 for (args
= insn
->args
;; ++args
)
758 /* We are truly done. */
759 the_insn
.opcode
= opcode
;
760 /* Clean up the HI and LO mark. */
768 as_bad (_("Too many operands: %s"), s
);
771 /* ',' Args separator */
773 /* Must match a comma. */
776 /* Parse next operand. */
777 s
= parse_operand (s
, operand
);
782 /* It can be a 'a' register or 'i' operand. */
784 /* Macro move operand/reg. */
785 if (operand
->X_op
== O_register
)
787 /* Its a register. */
792 /* The immediate 16 bits literal, bit 0-15. */
794 /* offset, unsigned. */
796 /* offset, signed. */
797 if (operand
->X_op
== O_constant
)
800 operand
->X_add_number
>>= 16;
802 opcode
|= operand
->X_add_number
& 0xFFFF;
804 if (the_insn
.HI
&& the_insn
.LO
)
805 as_bad (_("Both the_insn.HI and the_insn.LO are set : %s"), s
);
814 the_insn
.reloc
= (the_insn
.HI
) ? RELOC_DLX_HI16
815 : (the_insn
.LO
? RELOC_DLX_LO16
: RELOC_DLX_16
);
816 the_insn
.reloc_offset
= 2;
819 the_insn
.exp
= * operand
;
825 /* offset, signed. */
826 if (operand
->X_op
== O_constant
)
828 opcode
|= operand
->X_add_number
& 0xFFFF;
831 the_insn
.reloc
= RELOC_DLX_REL16
;
832 the_insn
.reloc_offset
= 0; /* BIG-ENDIAN Byte 3 of insn. */
835 the_insn
.exp
= *operand
;
838 /* The immediate 26 bits literal, bit 0-25. */
840 /* offset, signed. */
841 if (operand
->X_op
== O_constant
)
843 opcode
|= operand
->X_add_number
& 0x3FFFFFF;
846 the_insn
.reloc
= RELOC_DLX_REL26
;
847 the_insn
.reloc_offset
= 0; /* BIG-ENDIAN Byte 3 of insn. */
850 the_insn
.exp
= *operand
;
853 /* Type 'a' Register. */
855 /* A general register at bits 21-25, rs1. */
859 /* Type 'b' Register. */
861 /* A general register at bits 16-20, rs2/rd. */
865 /* Type 'c' Register. */
867 /* A general register at bits 11-15, rd. */
871 know (operand
->X_add_symbol
== 0);
872 know (operand
->X_op_symbol
== 0);
873 reg
= operand
->X_add_number
;
874 if (reg
& 0xffffffe0)
875 as_fatal (_("failed regnum sanity check."));
877 /* Got the register, now figure out where it goes in the opcode. */
878 opcode
|= reg
<< reg_shift
;
888 as_fatal (_("failed general register sanity check."));
895 /* Types or values of args don't match. */
896 as_bad (_("Invalid operands"));
901 /* Assemble a single instruction. Its label has already been handled
902 by the generic front end. We just parse opcode and operands, and
903 produce the bytes of data and relocation. */
906 md_assemble (char *str
)
915 dwarf2_emit_insn (4);
917 /* Put out the opcode. */
918 md_number_to_chars (toP
, the_insn
.opcode
, 4);
920 /* Put out the symbol-dependent stuff. */
921 if (the_insn
.reloc
!= NO_RELOC
)
923 fixP
= fix_new_exp (frag_now
,
924 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
),
925 the_insn
.size
, & the_insn
.exp
, the_insn
.pcrel
,
928 /* Turn off complaints that the addend is
929 too large for things like foo+100000@ha. */
930 switch (the_insn
.reloc
)
934 fixP
->fx_no_overflow
= 1;
940 switch (fixP
->fx_r_type
)
942 case RELOC_DLX_REL26
:
943 bitP
= malloc (sizeof (bit_fixS
));
944 bitP
->fx_bit_size
= 26;
945 bitP
->fx_bit_offset
= 25;
946 bitP
->fx_bit_base
= the_insn
.opcode
& 0xFC000000;
947 bitP
->fx_bit_base_adj
= 0;
948 bitP
->fx_bit_max
= 0;
949 bitP
->fx_bit_min
= 0;
950 bitP
->fx_bit_add
= 0x03FFFFFF;
951 fixP
->fx_bit_fixP
= bitP
;
954 case RELOC_DLX_REL16
:
955 bitP
= malloc (sizeof (bit_fixS
));
956 bitP
->fx_bit_size
= 16;
957 bitP
->fx_bit_offset
= 15;
958 bitP
->fx_bit_base
= the_insn
.opcode
& 0xFFFF0000;
959 bitP
->fx_bit_base_adj
= 0;
960 bitP
->fx_bit_max
= 0;
961 bitP
->fx_bit_min
= 0;
962 bitP
->fx_bit_add
= 0x0000FFFF;
963 fixP
->fx_bit_fixP
= bitP
;
966 bitP
= malloc (sizeof (bit_fixS
));
967 bitP
->fx_bit_size
= 16;
968 bitP
->fx_bit_offset
= 15;
969 bitP
->fx_bit_base
= the_insn
.opcode
& 0xFFFF0000;
970 bitP
->fx_bit_base_adj
= 0;
971 bitP
->fx_bit_max
= 0;
972 bitP
->fx_bit_min
= 0;
973 bitP
->fx_bit_add
= 0x0000FFFF;
974 fixP
->fx_bit_fixP
= bitP
;
977 fixP
->fx_bit_fixP
= NULL
;
983 /* This is identical to the md_atof in m68k.c. I think this is right,
984 but I'm not sure. Dlx will not use it anyway, so I just leave it
988 md_atof (int type
, char *litP
, int *sizeP
)
990 return ieee_md_atof (type
, litP
, sizeP
, TRUE
);
993 /* Write out big-endian. */
995 md_number_to_chars (char *buf
, valueT val
, int n
)
997 number_to_chars_bigendian (buf
, val
, n
);
1001 md_dlx_fix_adjustable (fixS
*fixP
)
1003 /* We need the symbol name for the VTABLE entries. */
1004 return (fixP
->fx_r_type
!= BFD_RELOC_VTABLE_INHERIT
1005 && fixP
->fx_r_type
!= BFD_RELOC_VTABLE_ENTRY
);
1009 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
1012 char *place
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
1014 switch (fixP
->fx_r_type
)
1016 case RELOC_DLX_LO16
:
1017 case RELOC_DLX_REL16
:
1018 if (fixP
->fx_bit_fixP
!= NULL
)
1020 val
= (val
& 0x0000FFFF) | fixP
->fx_bit_fixP
->fx_bit_base
;
1021 free (fixP
->fx_bit_fixP
);
1022 fixP
->fx_bit_fixP
= NULL
;
1026 know ((fixP
->fx_bit_fixP
!= NULL
));
1030 case RELOC_DLX_HI16
:
1031 if (fixP
->fx_bit_fixP
!= NULL
)
1033 val
= (val
>> 16) | fixP
->fx_bit_fixP
->fx_bit_base
;
1034 free (fixP
->fx_bit_fixP
);
1035 fixP
->fx_bit_fixP
= NULL
;
1039 know ((fixP
->fx_bit_fixP
!= NULL
));
1043 case RELOC_DLX_REL26
:
1044 if (fixP
->fx_bit_fixP
!= NULL
)
1046 val
= (val
& 0x03FFFFFF) | fixP
->fx_bit_fixP
->fx_bit_base
;
1047 free (fixP
->fx_bit_fixP
);
1048 fixP
->fx_bit_fixP
= NULL
;
1052 know ((fixP
->fx_bit_fixP
!= NULL
));
1056 case BFD_RELOC_VTABLE_INHERIT
:
1057 /* This borrowed from tc-ppc.c on a whim. */
1060 && !S_IS_DEFINED (fixP
->fx_addsy
)
1061 && !S_IS_WEAK (fixP
->fx_addsy
))
1062 S_SET_WEAK (fixP
->fx_addsy
);
1065 case BFD_RELOC_VTABLE_ENTRY
:
1073 number_to_chars_bigendian (place
, val
, fixP
->fx_size
);
1074 if (fixP
->fx_addsy
== NULL
)
1078 const char *md_shortopts
= "";
1080 struct option md_longopts
[] =
1082 {NULL
, no_argument
, NULL
, 0}
1085 size_t md_longopts_size
= sizeof (md_longopts
);
1088 md_parse_option (int c ATTRIBUTE_UNUSED
,
1089 char *arg ATTRIBUTE_UNUSED
)
1095 md_show_usage (FILE *stream ATTRIBUTE_UNUSED
)
1099 /* This is called when a line is unrecognized. */
1102 dlx_unrecognized_line (int c
)
1107 if (c
!= '$' || ! ISDIGIT ((unsigned char) input_line_pointer
[0]))
1110 s
= input_line_pointer
;
1113 while (ISDIGIT ((unsigned char) *s
))
1115 lab
= lab
* 10 + *s
- '0';
1120 /* Not a label definition. */
1123 if (dollar_label_defined (lab
))
1125 as_bad (_("label \"$%d\" redefined"), lab
);
1129 define_dollar_label (lab
);
1130 colon (dollar_label_name (lab
, 0));
1131 input_line_pointer
= s
+ 1;
1136 /* Default the values of symbols known that should be "predefined". We
1137 don't bother to predefine them unless you actually use one, since there
1138 are a lot of them. */
1141 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
1146 /* Parse an operand that is machine-specific, the function was called
1147 in expr.c by operand() function, when everything failed before it
1151 md_operand (expressionS
* expressionP
)
1153 /* Check for the #number representation */
1154 if (input_line_pointer
[0] == '#' &&
1155 ISDIGIT ((unsigned char) input_line_pointer
[1]))
1157 /* We have a numeric number expression. No biggy. */
1158 input_line_pointer
+= 1; /* Skip # */
1160 (void) expression (expressionP
);
1162 if (expressionP
->X_op
!= O_constant
)
1163 as_bad (_("Invalid expression after # number\n"));
1169 /* Round up a section size to the appropriate boundary. */
1172 md_section_align (segT segment ATTRIBUTE_UNUSED
,
1175 /* Byte alignment is fine. */
1179 /* Exactly what point is a PC-relative offset relative TO?
1180 On the 29000, they're relative to the address of the instruction,
1181 which we have set up as the address of the fixup too. */
1184 md_pcrel_from (fixS
* fixP
)
1186 return 4 + fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1189 /* Translate internal representation of relocation info to BFD target
1191 FIXME: To what extent can we get all relevant targets to use this?
1192 The above FIXME is from a29k, but I think it is also needed here. */
1195 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
,
1200 reloc
= xmalloc (sizeof (arelent
));
1201 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
1203 if (reloc
->howto
== NULL
)
1205 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1206 _("internal error: can't export reloc type %d (`%s')"),
1208 bfd_get_reloc_code_name (fixP
->fx_r_type
));
1212 gas_assert (!fixP
->fx_pcrel
== !reloc
->howto
->pc_relative
);
1214 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
1215 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixP
->fx_addsy
);
1216 reloc
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1218 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1219 reloc
->address
= fixP
->fx_offset
;
1226 dlx_pseudo_table
[] =
1228 /* Some additional ops that are used by gcc-dlx. */
1229 {"asciiz", stringer
, 8 + 1},
1233 {"proc", s_proc
, 0},
1234 {"endproc", s_proc
, 1},
1239 dlx_pop_insert (void)
1241 pop_insert (dlx_pseudo_table
);