1 /* tc-z80.c -- Assemble code for the Zilog Z80 and ASCII R800
2 Copyright (C) 2005-2014 Free Software Foundation, Inc.
3 Contributed by Arnold Metselaar <arnold_m@operamail.com>
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
23 #include "safe-ctype.h"
26 /* Exported constants. */
27 const char comment_chars
[] = ";\0";
28 const char line_comment_chars
[] = "#;\0";
29 const char line_separator_chars
[] = "\0";
30 const char EXP_CHARS
[] = "eE\0";
31 const char FLT_CHARS
[] = "RrFf\0";
33 /* For machine specific options. */
34 const char * md_shortopts
= ""; /* None yet. */
38 OPTION_MACH_Z80
= OPTION_MD_BASE
,
53 struct option md_longopts
[] =
55 { "z80", no_argument
, NULL
, OPTION_MACH_Z80
},
56 { "r800", no_argument
, NULL
, OPTION_MACH_R800
},
57 { "ignore-undocumented-instructions", no_argument
, NULL
, OPTION_MACH_IUD
},
58 { "Wnud", no_argument
, NULL
, OPTION_MACH_IUD
},
59 { "warn-undocumented-instructions", no_argument
, NULL
, OPTION_MACH_WUD
},
60 { "Wud", no_argument
, NULL
, OPTION_MACH_WUD
},
61 { "forbid-undocumented-instructions", no_argument
, NULL
, OPTION_MACH_FUD
},
62 { "Fud", no_argument
, NULL
, OPTION_MACH_FUD
},
63 { "ignore-unportable-instructions", no_argument
, NULL
, OPTION_MACH_IUP
},
64 { "Wnup", no_argument
, NULL
, OPTION_MACH_IUP
},
65 { "warn-unportable-instructions", no_argument
, NULL
, OPTION_MACH_WUP
},
66 { "Wup", no_argument
, NULL
, OPTION_MACH_WUP
},
67 { "forbid-unportable-instructions", no_argument
, NULL
, OPTION_MACH_FUP
},
68 { "Fup", no_argument
, NULL
, OPTION_MACH_FUP
},
70 { NULL
, no_argument
, NULL
, 0 }
73 size_t md_longopts_size
= sizeof (md_longopts
);
75 extern int coff_flags
;
76 /* Instruction classes that silently assembled. */
77 static int ins_ok
= INS_Z80
| INS_UNDOC
;
78 /* Instruction classes that generate errors. */
79 static int ins_err
= INS_R800
;
80 /* Instruction classes actually used, determines machine type. */
81 static int ins_used
= INS_Z80
;
84 md_parse_option (int c
, char* arg ATTRIBUTE_UNUSED
)
94 case OPTION_MACH_R800
:
95 ins_ok
= INS_Z80
| INS_UNDOC
| INS_R800
;
100 ins_err
&= ~INS_UNDOC
;
102 case OPTION_MACH_IUP
:
103 ins_ok
|= INS_UNDOC
| INS_UNPORT
;
104 ins_err
&= ~(INS_UNDOC
| INS_UNPORT
);
106 case OPTION_MACH_WUD
:
107 if ((ins_ok
& INS_R800
) == 0)
109 ins_ok
&= ~(INS_UNDOC
|INS_UNPORT
);
110 ins_err
&= ~INS_UNDOC
;
113 case OPTION_MACH_WUP
:
114 ins_ok
&= ~INS_UNPORT
;
115 ins_err
&= ~(INS_UNDOC
|INS_UNPORT
);
117 case OPTION_MACH_FUD
:
118 if ((ins_ok
& INS_R800
) == 0)
120 ins_ok
&= (INS_UNDOC
| INS_UNPORT
);
121 ins_err
|= INS_UNDOC
| INS_UNPORT
;
124 case OPTION_MACH_FUP
:
125 ins_ok
&= ~INS_UNPORT
;
126 ins_err
|= INS_UNPORT
;
134 md_show_usage (FILE * f
)
137 CPU model/instruction set options:\n\
139 -z80\t\t assemble for Z80\n\
140 -ignore-undocumented-instructions\n\
142 \tsilently assemble undocumented Z80-instructions that work on R800\n\
143 -ignore-unportable-instructions\n\
145 \tsilently assemble all undocumented Z80-instructions\n\
146 -warn-undocumented-instructions\n\
148 \tissue warnings for undocumented Z80-instructions that work on R800\n\
149 -warn-unportable-instructions\n\
151 \tissue warnings for other undocumented Z80-instructions\n\
152 -forbid-undocumented-instructions\n\
154 \ttreat all undocumented z80-instructions as errors\n\
155 -forbid-unportable-instructions\n\
157 \ttreat undocumented z80-instructions that do not work on R800 as errors\n\
158 -r800\t assemble for R800\n\n\
159 Default: -z80 -ignore-undocument-instructions -warn-unportable-instructions.\n");
162 static symbolS
* zero
;
169 #define R_STACKABLE (0x80)
170 #define R_ARITH (0x40)
173 #define R_INDEX (R_IX | R_IY)
182 #define REG_F (6 | 8)
186 #define REG_AF (3 | R_STACKABLE)
187 #define REG_BC (0 | R_STACKABLE | R_ARITH)
188 #define REG_DE (1 | R_STACKABLE | R_ARITH)
189 #define REG_HL (2 | R_STACKABLE | R_ARITH)
190 #define REG_IX (REG_HL | R_IX)
191 #define REG_IY (REG_HL | R_IY)
192 #define REG_SP (3 | R_ARITH)
194 static const struct reg_entry regtable
[] =
209 {"ixh",REG_H
| R_IX
},
210 {"ixl",REG_L
| R_IX
},
212 {"iyh",REG_H
| R_IY
},
213 {"iyl",REG_L
| R_IY
},
219 #define BUFLEN 8 /* Large enough for any keyword. */
224 expressionS nul
, reg
;
226 unsigned int i
, j
, k
;
229 reg
.X_op
= O_register
;
231 reg
.X_add_symbol
= reg
.X_op_symbol
= 0;
232 for ( i
= 0 ; i
< ARRAY_SIZE ( regtable
) ; ++i
)
234 reg
.X_add_number
= regtable
[i
].number
;
235 k
= strlen ( regtable
[i
].name
);
239 for ( j
= ( 1<<k
) ; j
; --j
)
241 for ( k
= 0 ; regtable
[i
].name
[k
] ; ++k
)
243 buf
[k
] = ( j
& ( 1<<k
) ) ? TOUPPER ( regtable
[i
].name
[k
] ) : regtable
[i
].name
[k
];
245 symbolS
* psym
= symbol_find_or_make(buf
);
246 S_SET_SEGMENT(psym
, reg_section
);
247 symbol_set_value_expression(psym
, ®
);
251 p
= input_line_pointer
;
252 input_line_pointer
= "0";
255 input_line_pointer
= p
;
256 zero
= make_expr_symbol (& nul
);
257 /* We do not use relaxation (yet). */
266 if (ins_used
& (INS_UNPORT
| INS_R800
))
267 ins_used
|= INS_UNDOC
;
272 mach_type
= bfd_mach_z80strict
;
274 case INS_Z80
|INS_UNDOC
:
275 mach_type
= bfd_mach_z80
;
277 case INS_Z80
|INS_UNDOC
|INS_UNPORT
:
278 mach_type
= bfd_mach_z80full
;
280 case INS_Z80
|INS_UNDOC
|INS_R800
:
281 mach_type
= bfd_mach_r800
;
287 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, mach_type
);
291 skip_space (const char *s
)
293 while (*s
== ' ' || *s
== '\t')
298 /* A non-zero return-value causes a continue in the
299 function read_a_source_file () in ../read.c. */
301 z80_start_line_hook (void)
306 /* Convert one character constants. */
307 for (p
= input_line_pointer
; *p
&& *p
!= '\n'; ++p
)
312 if (p
[1] != 0 && p
[1] != '\'' && p
[2] == '\'')
314 snprintf (buf
, 4, "%3d", (unsigned char)p
[1]);
321 for (quote
= *p
++; quote
!= *p
&& '\n' != *p
; ++p
)
325 as_bad (_("-- unterminated string"));
326 ignore_rest_of_line ();
332 /* Check for <label>[:] [.](EQU|DEFL) <value>. */
333 if (is_name_beginner (*input_line_pointer
))
335 char c
, *rest
, *line_start
;
338 line_start
= input_line_pointer
;
342 c
= get_symbol_end ();
343 rest
= input_line_pointer
+ 1;
347 if (*rest
== ' ' || *rest
== '\t')
351 if (strncasecmp (rest
, "EQU", 3) == 0)
353 else if (strncasecmp (rest
, "DEFL", 4) == 0)
357 if (len
&& (!ISALPHA(rest
[len
]) ) )
359 /* Handle assignment here. */
360 if (line_start
[-1] == '\n')
362 bump_line_counters ();
365 input_line_pointer
= rest
+ len
- 1;
366 /* Allow redefining with "DEFL" (len == 4), but not with "EQU". */
367 equals (line_start
, len
== 4);
372 /* Restore line and pointer. */
373 *input_line_pointer
= c
;
374 input_line_pointer
= line_start
;
381 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
387 md_atof (int type ATTRIBUTE_UNUSED
, char *litP ATTRIBUTE_UNUSED
,
388 int *sizeP ATTRIBUTE_UNUSED
)
390 return _("floating point numbers are not implemented");
394 md_section_align (segT seg ATTRIBUTE_UNUSED
, valueT size
)
400 md_pcrel_from (fixS
* fixp
)
402 return fixp
->fx_where
+
403 fixp
->fx_frag
->fr_address
+ 1;
406 typedef const char * (asfunc
)(char, char, const char*);
408 typedef struct _table_t
416 /* Compares the key for structs that start with a char * to the key. */
418 key_cmp (const void * a
, const void * b
)
420 const char *str_a
, *str_b
;
422 str_a
= *((const char**)a
);
423 str_b
= *((const char**)b
);
424 return strcmp (str_a
, str_b
);
428 const char *key
= buf
;
430 /* Prevent an error on a line from also generating
431 a "junk at end of line" error message. */
432 static char err_flag
;
435 error (const char * message
)
437 as_bad ("%s", message
);
444 error (_("illegal operand"));
448 wrong_mach (int ins_type
)
455 p
= "undocumented instruction";
458 p
= "instruction does not work on R800";
461 p
= "instruction only works R800";
464 p
= 0; /* Not reachable. */
467 if (ins_type
& ins_err
)
470 as_warn ("%s", _(p
));
474 check_mach (int ins_type
)
476 if ((ins_type
& ins_ok
) == 0)
477 wrong_mach (ins_type
);
478 ins_used
|= ins_type
;
481 /* Check whether an expression is indirect. */
483 is_indir (const char *s
)
489 /* Indirection is indicated with parentheses. */
492 for (p
= s
, depth
= 0; *p
&& *p
!= ','; ++p
)
498 for (quote
= *p
++; quote
!= *p
&& *p
!= '\n'; ++p
)
499 if (*p
== '\\' && p
[1])
509 p
= skip_space (p
+ 1);
515 error (_("mismatched parentheses"));
521 error (_("mismatched parentheses"));
526 /* Check whether a symbol involves a register. */
528 contains_register(symbolS
*sym
)
532 expressionS
* ex
= symbol_get_value_expression(sym
);
533 return (O_register
== ex
->X_op
)
534 || (ex
->X_add_symbol
&& contains_register(ex
->X_add_symbol
))
535 || (ex
->X_op_symbol
&& contains_register(ex
->X_op_symbol
));
541 /* Parse general expression, not loooking for indexed adressing. */
543 parse_exp_not_indexed (const char *s
, expressionS
*op
)
549 op
->X_md
= indir
= is_indir (p
);
550 input_line_pointer
= (char*) s
;
555 error (_("missing operand"));
558 error (_("bad expression syntax"));
561 return input_line_pointer
;
564 /* Parse expression, change operator to O_md1 for indexed addressing*/
566 parse_exp (const char *s
, expressionS
*op
)
568 const char* res
= parse_exp_not_indexed (s
, op
);
573 if (op
->X_md
&& (O_register
== symbol_get_value_expression(op
->X_add_symbol
)->X_op
))
575 int rnum
= symbol_get_value_expression(op
->X_add_symbol
)->X_add_number
;
576 if ( ((REG_IX
!= rnum
) && (REG_IY
!= rnum
)) || contains_register(op
->X_op_symbol
) )
582 if (O_subtract
== op
->X_op
)
585 minus
.X_op
= O_uminus
;
586 minus
.X_add_number
= 0;
587 minus
.X_add_symbol
= op
->X_op_symbol
;
588 minus
.X_op_symbol
= 0;
589 op
->X_op_symbol
= make_expr_symbol(&minus
);
592 symbol_get_value_expression(op
->X_op_symbol
)->X_add_number
+= op
->X_add_number
;
593 op
->X_add_number
= rnum
;
594 op
->X_add_symbol
= op
->X_op_symbol
;
601 if ( op
->X_md
&& ((REG_IX
== op
->X_add_number
)||(REG_IY
== op
->X_add_number
)) )
603 op
->X_add_symbol
= zero
;
611 /* Condition codes, including some synonyms provided by HiTech zas. */
612 static const struct reg_entry cc_tab
[] =
630 /* Parse condition code. */
632 parse_cc (const char *s
, char * op
)
636 struct reg_entry
* cc_p
;
638 for (i
= 0; i
< BUFLEN
; ++i
)
640 if (!ISALPHA (s
[i
])) /* Condition codes consist of letters only. */
642 buf
[i
] = TOLOWER (s
[i
]);
646 && ((s
[i
] == 0) || (s
[i
] == ',')))
649 cc_p
= bsearch (&key
, cc_tab
, ARRAY_SIZE (cc_tab
),
650 sizeof (cc_tab
[0]), key_cmp
);
667 emit_insn (char prefix
, char opcode
, const char * args
)
682 void z80_cons_fix_new (fragS
*frag_p
, int offset
, int nbytes
, expressionS
*exp
)
684 bfd_reloc_code_real_type r
[4] =
692 if (nbytes
< 1 || nbytes
> 4)
694 as_bad (_("unsupported BFD relocation size %u"), nbytes
);
698 fix_new_exp (frag_p
, offset
, nbytes
, exp
, 0, r
[nbytes
-1]);
703 emit_byte (expressionS
* val
, bfd_reloc_code_real_type r_type
)
709 *p
= val
->X_add_number
;
710 if ( contains_register(val
->X_add_symbol
) || contains_register(val
->X_op_symbol
) )
714 else if ((r_type
== BFD_RELOC_8_PCREL
) && (val
->X_op
== O_constant
))
716 as_bad (_("cannot make a relative jump to an absolute location"));
718 else if (val
->X_op
== O_constant
)
721 hi
= (BFD_RELOC_8
== r_type
) ? 255 : 127;
723 if ((val
->X_add_number
< lo
) || (val
->X_add_number
> hi
))
725 if (r_type
== BFD_RELOC_Z80_DISP8
)
726 as_bad (_("offset too large"));
728 as_warn (_("overflow"));
733 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 1, val
,
734 (r_type
== BFD_RELOC_8_PCREL
) ? TRUE
: FALSE
, r_type
);
735 /* FIXME : Process constant offsets immediately. */
740 emit_word (expressionS
* val
)
745 if ( (val
->X_op
== O_register
)
746 || (val
->X_op
== O_md1
)
747 || contains_register(val
->X_add_symbol
)
748 || contains_register(val
->X_op_symbol
) )
752 *p
= val
->X_add_number
;
753 p
[1] = (val
->X_add_number
>>8);
754 if (val
->X_op
!= O_constant
)
755 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 2,
756 val
, FALSE
, BFD_RELOC_16
);
761 emit_mx (char prefix
, char opcode
, int shift
, expressionS
* arg
)
762 /* The operand m may be r, (hl), (ix+d), (iy+d),
763 if 0 == prefix m may also be ixl, ixh, iyl, iyh. */
768 rnum
= arg
->X_add_number
;
784 if ((prefix
== 0) && (rnum
& R_INDEX
))
786 prefix
= (rnum
& R_IX
) ? 0xDD : 0xFD;
787 check_mach (INS_UNDOC
);
796 q
= frag_more (prefix
? 2 : 1);
799 * q
++ = opcode
+ (rnum
<< shift
);
803 *q
++ = (rnum
& R_IX
) ? 0xDD : 0xFD;
804 *q
= (prefix
) ? prefix
: (opcode
+ (6 << shift
));
806 expressionS offset
= *arg
;
807 offset
.X_op
= O_symbol
;
808 offset
.X_add_number
= 0;
809 emit_byte (&offset
, BFD_RELOC_Z80_DISP8
);
814 *q
= opcode
+(6<<shift
);
822 /* The operand m may be r, (hl), (ix+d), (iy+d),
823 if 0 = prefix m may also be ixl, ixh, iyl, iyh. */
825 emit_m (char prefix
, char opcode
, const char *args
)
830 p
= parse_exp (args
, &arg_m
);
835 emit_mx (prefix
, opcode
, 0, &arg_m
);
843 /* The operand m may be as above or one of the undocumented
844 combinations (ix+d),r and (iy+d),r (if unportable instructions
847 emit_mr (char prefix
, char opcode
, const char *args
)
849 expressionS arg_m
, arg_r
;
852 p
= parse_exp (args
, & arg_m
);
859 p
= parse_exp (p
+ 1, & arg_r
);
861 if ((arg_r
.X_md
== 0)
862 && (arg_r
.X_op
== O_register
)
863 && (arg_r
.X_add_number
< 8))
864 opcode
+= arg_r
.X_add_number
-6; /* Emit_mx () will add 6. */
870 check_mach (INS_UNPORT
);
873 emit_mx (prefix
, opcode
, 0, & arg_m
);
882 emit_sx (char prefix
, char opcode
, expressionS
* arg_p
)
890 emit_mx (prefix
, opcode
, 0, arg_p
);
897 q
= frag_more (prefix
? 2 : 1);
901 emit_byte (arg_p
, BFD_RELOC_8
);
906 /* The operand s may be r, (hl), (ix+d), (iy+d), n. */
908 emit_s (char prefix
, char opcode
, const char *args
)
913 p
= parse_exp (args
, & arg_s
);
914 emit_sx (prefix
, opcode
, & arg_s
);
919 emit_call (char prefix ATTRIBUTE_UNUSED
, char opcode
, const char * args
)
922 const char *p
; char *q
;
924 p
= parse_exp_not_indexed (args
, &addr
);
936 /* Operand may be rr, r, (hl), (ix+d), (iy+d). */
938 emit_incdec (char prefix
, char opcode
, const char * args
)
942 const char *p
; char *q
;
944 p
= parse_exp (args
, &operand
);
945 rnum
= operand
.X_add_number
;
947 && (operand
.X_op
== O_register
)
950 q
= frag_more ((rnum
& R_INDEX
) ? 2 : 1);
952 *q
++ = (rnum
& R_IX
) ? 0xDD : 0xFD;
953 *q
= prefix
+ ((rnum
& 3) << 4);
957 if ((operand
.X_op
== O_md1
) || (operand
.X_op
== O_register
))
958 emit_mx (0, opcode
, 3, & operand
);
966 emit_jr (char prefix ATTRIBUTE_UNUSED
, char opcode
, const char * args
)
972 p
= parse_exp_not_indexed (args
, &addr
);
979 emit_byte (&addr
, BFD_RELOC_8_PCREL
);
985 emit_jp (char prefix
, char opcode
, const char * args
)
992 p
= parse_exp_not_indexed (args
, & addr
);
995 rnum
= addr
.X_add_number
;
996 if ((O_register
== addr
.X_op
) && (REG_HL
== (rnum
& ~R_INDEX
)))
998 q
= frag_more ((rnum
& R_INDEX
) ? 2 : 1);
1000 *q
++ = (rnum
& R_IX
) ? 0xDD : 0xFD;
1016 emit_im (char prefix
, char opcode
, const char * args
)
1022 p
= parse_exp (args
, & mode
);
1023 if (mode
.X_md
|| (mode
.X_op
!= O_constant
))
1026 switch (mode
.X_add_number
)
1030 ++mode
.X_add_number
;
1035 *q
= opcode
+ 8*mode
.X_add_number
;
1044 emit_pop (char prefix ATTRIBUTE_UNUSED
, char opcode
, const char * args
)
1050 p
= parse_exp (args
, & regp
);
1052 && (regp
.X_op
== O_register
)
1053 && (regp
.X_add_number
& R_STACKABLE
))
1057 rnum
= regp
.X_add_number
;
1061 *q
++ = (rnum
&R_IX
)?0xDD:0xFD;
1065 *q
= opcode
+ ((rnum
& 3) << 4);
1074 emit_retcc (char prefix ATTRIBUTE_UNUSED
, char opcode
, const char * args
)
1079 p
= parse_cc (args
, &cc
);
1085 return p
? p
: args
;
1089 emit_adc (char prefix
, char opcode
, const char * args
)
1096 p
= parse_exp (args
, &term
);
1099 error (_("bad instruction syntax"));
1103 if ((term
.X_md
) || (term
.X_op
!= O_register
))
1106 switch (term
.X_add_number
)
1109 p
= emit_s (0, prefix
, p
);
1112 p
= parse_exp (p
, &term
);
1113 if ((!term
.X_md
) && (term
.X_op
== O_register
))
1115 rnum
= term
.X_add_number
;
1116 if (R_ARITH
== (rnum
& (R_ARITH
| R_INDEX
)))
1120 *q
= opcode
+ ((rnum
& 3) << 4);
1132 emit_add (char prefix
, char opcode
, const char * args
)
1139 p
= parse_exp (args
, &term
);
1142 error (_("bad instruction syntax"));
1146 if ((term
.X_md
) || (term
.X_op
!= O_register
))
1149 switch (term
.X_add_number
& ~R_INDEX
)
1152 p
= emit_s (0, prefix
, p
);
1155 lhs
= term
.X_add_number
;
1156 p
= parse_exp (p
, &term
);
1157 if ((!term
.X_md
) && (term
.X_op
== O_register
))
1159 rhs
= term
.X_add_number
;
1161 && ((rhs
== lhs
) || ((rhs
& ~R_INDEX
) != REG_HL
)))
1163 q
= frag_more ((lhs
& R_INDEX
) ? 2 : 1);
1165 *q
++ = (lhs
& R_IX
) ? 0xDD : 0xFD;
1166 *q
= opcode
+ ((rhs
& 3) << 4);
1178 emit_bit (char prefix
, char opcode
, const char * args
)
1184 p
= parse_exp (args
, &b
);
1186 error (_("bad instruction syntax"));
1188 bn
= b
.X_add_number
;
1190 && (b
.X_op
== O_constant
)
1195 /* Bit : no optional third operand. */
1196 p
= emit_m (prefix
, opcode
+ (bn
<< 3), p
);
1198 /* Set, res : resulting byte can be copied to register. */
1199 p
= emit_mr (prefix
, opcode
+ (bn
<< 3), p
);
1207 emit_jpcc (char prefix
, char opcode
, const char * args
)
1212 p
= parse_cc (args
, & cc
);
1213 if (p
&& *p
++ == ',')
1214 p
= emit_call (0, opcode
+ cc
, p
);
1216 p
= (prefix
== (char)0xC3)
1217 ? emit_jp (0xE9, prefix
, args
)
1218 : emit_call (0, prefix
, args
);
1223 emit_jrcc (char prefix
, char opcode
, const char * args
)
1228 p
= parse_cc (args
, &cc
);
1229 if (p
&& *p
++ == ',')
1232 error (_("condition code invalid for jr"));
1234 p
= emit_jr (0, opcode
+ cc
, p
);
1237 p
= emit_jr (0, prefix
, args
);
1243 emit_ex (char prefix_in ATTRIBUTE_UNUSED
,
1244 char opcode_in ATTRIBUTE_UNUSED
, const char * args
)
1248 char prefix
, opcode
;
1250 p
= parse_exp_not_indexed (args
, &op
);
1254 error (_("bad instruction syntax"));
1258 prefix
= opcode
= 0;
1259 if (op
.X_op
== O_register
)
1260 switch (op
.X_add_number
| (op
.X_md
? 0x8000 : 0))
1263 if (TOLOWER (*p
++) == 'a' && TOLOWER (*p
++) == 'f')
1265 /* The scrubber changes '\'' to '`' in this context. */
1272 if (TOLOWER (*p
++) == 'h' && TOLOWER (*p
++) == 'l')
1276 p
= parse_exp (p
, & op
);
1277 if (op
.X_op
== O_register
1279 && (op
.X_add_number
& ~R_INDEX
) == REG_HL
)
1282 if (R_INDEX
& op
.X_add_number
)
1283 prefix
= (R_IX
& op
.X_add_number
) ? 0xDD : 0xFD;
1288 emit_insn (prefix
, opcode
, p
);
1296 emit_in (char prefix ATTRIBUTE_UNUSED
, char opcode ATTRIBUTE_UNUSED
,
1299 expressionS reg
, port
;
1303 p
= parse_exp (args
, ®
);
1306 error (_("bad instruction syntax"));
1310 p
= parse_exp (p
, &port
);
1312 && reg
.X_op
== O_register
1313 && (reg
.X_add_number
<= 7 || reg
.X_add_number
== REG_F
)
1316 if (port
.X_op
!= O_md1
&& port
.X_op
!= O_register
)
1318 if (REG_A
== reg
.X_add_number
)
1322 emit_byte (&port
, BFD_RELOC_8
);
1329 if (port
.X_add_number
== REG_C
)
1331 if (reg
.X_add_number
== REG_F
)
1332 check_mach (INS_UNDOC
);
1337 *q
= 0x40|((reg
.X_add_number
&7)<<3);
1350 emit_out (char prefix ATTRIBUTE_UNUSED
, char opcode ATTRIBUTE_UNUSED
,
1353 expressionS reg
, port
;
1357 p
= parse_exp (args
, & port
);
1360 error (_("bad instruction syntax"));
1363 p
= parse_exp (p
, ®
);
1365 { ill_op (); return p
; }
1366 /* Allow "out (c), 0" as unportable instruction. */
1367 if (reg
.X_op
== O_constant
&& reg
.X_add_number
== 0)
1369 check_mach (INS_UNPORT
);
1370 reg
.X_op
= O_register
;
1371 reg
.X_add_number
= 6;
1374 || reg
.X_op
!= O_register
1375 || reg
.X_add_number
> 7)
1378 if (port
.X_op
!= O_register
&& port
.X_op
!= O_md1
)
1380 if (REG_A
== reg
.X_add_number
)
1384 emit_byte (&port
, BFD_RELOC_8
);
1391 if (REG_C
== port
.X_add_number
)
1395 *q
= 0x41 | (reg
.X_add_number
<< 3);
1404 emit_rst (char prefix ATTRIBUTE_UNUSED
, char opcode
, const char * args
)
1410 p
= parse_exp_not_indexed (args
, &addr
);
1411 if (addr
.X_op
!= O_constant
)
1413 error ("rst needs constant address");
1417 if (addr
.X_add_number
& ~(7 << 3))
1422 *q
= opcode
+ (addr
.X_add_number
& (7 << 3));
1428 emit_ldxhl (char prefix
, char opcode
, expressionS
*src
, expressionS
*d
)
1436 if (src
->X_op
== O_register
)
1438 if (src
->X_add_number
>7)
1447 *q
= opcode
+ src
->X_add_number
;
1449 emit_byte (d
, BFD_RELOC_Z80_DISP8
);
1462 emit_byte (d
, BFD_RELOC_Z80_DISP8
);
1463 emit_byte (src
, BFD_RELOC_8
);
1469 emit_ldreg (int dest
, expressionS
* src
)
1476 /* 8 Bit ld group: */
1479 if (src
->X_md
== 0 && src
->X_op
== O_register
&& src
->X_add_number
== REG_A
)
1483 *q
= (dest
== REG_I
) ? 0x47 : 0x4F;
1490 if ((src
->X_md
) && src
->X_op
!= O_register
&& src
->X_op
!= O_md1
)
1499 && src
->X_op
== O_register
1500 && (src
->X_add_number
== REG_BC
|| src
->X_add_number
== REG_DE
))
1503 *q
= 0x0A + ((src
->X_add_number
& 1) << 4);
1508 && src
->X_op
== O_register
1509 && (src
->X_add_number
== REG_R
|| src
->X_add_number
== REG_I
))
1513 *q
= (src
->X_add_number
== REG_I
) ? 0x57 : 0x5F;
1521 emit_sx (0, 0x40 + (dest
<< 3), src
);
1526 if ((src
->X_md
== 0)
1527 && (src
->X_op
== O_register
)
1528 && (src
->X_add_number
& R_INDEX
))
1531 emit_sx (0, 0x40 + (dest
<< 3), src
);
1543 check_mach (INS_UNDOC
);
1544 if (src
-> X_op
== O_register
)
1546 rnum
= src
->X_add_number
;
1547 if ((rnum
& ~R_INDEX
) < 8
1548 && ((rnum
& R_INDEX
) == (dest
& R_INDEX
)
1549 || ( (rnum
& ~R_INDEX
) != REG_H
1550 && (rnum
& ~R_INDEX
) != REG_L
)))
1553 *q
++ = (dest
& R_IX
) ? 0xDD : 0xFD;
1554 *q
= 0x40 + ((dest
& 0x07) << 3) + (rnum
& 7);
1562 *q
++ = (dest
& R_IX
) ? 0xDD : 0xFD;
1563 *q
= 0x06 + ((dest
& 0x07) << 3);
1564 emit_byte (src
, BFD_RELOC_8
);
1568 /* 16 Bit ld group: */
1571 && src
->X_op
== O_register
1572 && REG_HL
== (src
->X_add_number
&~ R_INDEX
))
1574 q
= frag_more ((src
->X_add_number
& R_INDEX
) ? 2 : 1);
1575 if (src
->X_add_number
& R_INDEX
)
1576 *q
++ = (src
->X_add_number
& R_IX
) ? 0xDD : 0xFD;
1583 if (src
->X_op
== O_register
|| src
->X_op
== O_md1
)
1585 q
= frag_more (src
->X_md
? 2 : 1);
1589 *q
= 0x4B + ((dest
& 3) << 4);
1592 *q
= 0x01 + ((dest
& 3) << 4);
1599 if (src
->X_op
== O_register
|| src
->X_op
== O_md1
)
1601 q
= frag_more ((dest
& R_INDEX
) ? 2 : 1);
1603 * q
++ = (dest
& R_IX
) ? 0xDD : 0xFD;
1604 *q
= (src
->X_md
) ? 0x2A : 0x21;
1619 emit_ld (char prefix_in ATTRIBUTE_UNUSED
, char opcode_in ATTRIBUTE_UNUSED
,
1622 expressionS dst
, src
;
1625 char prefix
, opcode
;
1627 p
= parse_exp (args
, &dst
);
1629 error (_("bad instruction syntax"));
1630 p
= parse_exp (p
, &src
);
1636 expressionS dst_offset
= dst
;
1637 dst_offset
.X_op
= O_symbol
;
1638 dst_offset
.X_add_number
= 0;
1639 emit_ldxhl ((dst
.X_add_number
& R_IX
) ? 0xDD : 0xFD, 0x70,
1647 switch (dst
.X_add_number
)
1651 if (src
.X_md
== 0 && src
.X_op
== O_register
&& src
.X_add_number
== REG_A
)
1654 *q
= 0x02 + ( (dst
.X_add_number
& 1) << 4);
1660 emit_ldxhl (0, 0x70, &src
, NULL
);
1667 emit_ldreg (dst
.X_add_number
, &src
);
1671 if (src
.X_md
!= 0 || src
.X_op
!= O_register
)
1673 prefix
= opcode
= 0;
1674 switch (src
.X_add_number
)
1677 opcode
= 0x32; break;
1678 case REG_BC
: case REG_DE
: case REG_SP
:
1679 prefix
= 0xED; opcode
= 0x43 + ((src
.X_add_number
&3)<<4); break;
1681 opcode
= 0x22; break;
1683 prefix
= 0xDD; opcode
= 0x22; break;
1685 prefix
= 0xFD; opcode
= 0x22; break;
1689 q
= frag_more (prefix
?2:1);
1702 emit_data (int size ATTRIBUTE_UNUSED
)
1709 if (is_it_end_of_statement ())
1711 demand_empty_rest_of_line ();
1714 p
= skip_space (input_line_pointer
);
1718 if (*p
== '\"' || *p
== '\'')
1720 for (quote
= *p
, q
= ++p
, cnt
= 0; *p
&& quote
!= *p
; ++p
, ++cnt
)
1722 u
= frag_more (cnt
);
1725 as_warn (_("unterminated string"));
1727 p
= skip_space (p
+1);
1731 p
= parse_exp (p
, &exp
);
1732 if (exp
.X_op
== O_md1
|| exp
.X_op
== O_register
)
1738 as_warn (_("parentheses ignored"));
1739 emit_byte (&exp
, BFD_RELOC_8
);
1743 while (*p
++ == ',') ;
1744 input_line_pointer
= (char *)(p
-1);
1748 emit_mulub (char prefix ATTRIBUTE_UNUSED
, char opcode
, const char * args
)
1752 p
= skip_space (args
);
1753 if (TOLOWER (*p
++) != 'a' || *p
++ != ',')
1759 reg
= TOLOWER (*p
++);
1766 check_mach (INS_R800
);
1767 if (!*skip_space (p
))
1771 *q
= opcode
+ ((reg
- 'b') << 3);
1782 emit_muluw (char prefix ATTRIBUTE_UNUSED
, char opcode
, const char * args
)
1786 p
= skip_space (args
);
1787 if (TOLOWER (*p
++) != 'h' || TOLOWER (*p
++) != 'l' || *p
++ != ',')
1794 p
= parse_exp (p
, & reg
);
1796 if ((!reg
.X_md
) && reg
.X_op
== O_register
)
1797 switch (reg
.X_add_number
)
1801 check_mach (INS_R800
);
1804 *q
= opcode
+ ((reg
.X_add_number
& 3) << 4);
1813 /* Port specific pseudo ops. */
1814 const pseudo_typeS md_pseudo_table
[] =
1816 { "db" , emit_data
, 1},
1819 { "def24", cons
, 3},
1820 { "def32", cons
, 4},
1821 { "defb", emit_data
, 1},
1822 { "defs", s_space
, 1}, /* Synonym for ds on some assemblers. */
1824 { "ds", s_space
, 1}, /* Fill with bytes rather than words. */
1826 { "psect", obj_coff_section
, 0}, /* TODO: Translate attributes. */
1827 { "set", 0, 0}, /* Real instruction on z80. */
1831 static table_t instab
[] =
1833 { "adc", 0x88, 0x4A, emit_adc
},
1834 { "add", 0x80, 0x09, emit_add
},
1835 { "and", 0x00, 0xA0, emit_s
},
1836 { "bit", 0xCB, 0x40, emit_bit
},
1837 { "call", 0xCD, 0xC4, emit_jpcc
},
1838 { "ccf", 0x00, 0x3F, emit_insn
},
1839 { "cp", 0x00, 0xB8, emit_s
},
1840 { "cpd", 0xED, 0xA9, emit_insn
},
1841 { "cpdr", 0xED, 0xB9, emit_insn
},
1842 { "cpi", 0xED, 0xA1, emit_insn
},
1843 { "cpir", 0xED, 0xB1, emit_insn
},
1844 { "cpl", 0x00, 0x2F, emit_insn
},
1845 { "daa", 0x00, 0x27, emit_insn
},
1846 { "dec", 0x0B, 0x05, emit_incdec
},
1847 { "di", 0x00, 0xF3, emit_insn
},
1848 { "djnz", 0x00, 0x10, emit_jr
},
1849 { "ei", 0x00, 0xFB, emit_insn
},
1850 { "ex", 0x00, 0x00, emit_ex
},
1851 { "exx", 0x00, 0xD9, emit_insn
},
1852 { "halt", 0x00, 0x76, emit_insn
},
1853 { "im", 0xED, 0x46, emit_im
},
1854 { "in", 0x00, 0x00, emit_in
},
1855 { "inc", 0x03, 0x04, emit_incdec
},
1856 { "ind", 0xED, 0xAA, emit_insn
},
1857 { "indr", 0xED, 0xBA, emit_insn
},
1858 { "ini", 0xED, 0xA2, emit_insn
},
1859 { "inir", 0xED, 0xB2, emit_insn
},
1860 { "jp", 0xC3, 0xC2, emit_jpcc
},
1861 { "jr", 0x18, 0x20, emit_jrcc
},
1862 { "ld", 0x00, 0x00, emit_ld
},
1863 { "ldd", 0xED, 0xA8, emit_insn
},
1864 { "lddr", 0xED, 0xB8, emit_insn
},
1865 { "ldi", 0xED, 0xA0, emit_insn
},
1866 { "ldir", 0xED, 0xB0, emit_insn
},
1867 { "mulub", 0xED, 0xC5, emit_mulub
}, /* R800 only. */
1868 { "muluw", 0xED, 0xC3, emit_muluw
}, /* R800 only. */
1869 { "neg", 0xed, 0x44, emit_insn
},
1870 { "nop", 0x00, 0x00, emit_insn
},
1871 { "or", 0x00, 0xB0, emit_s
},
1872 { "otdr", 0xED, 0xBB, emit_insn
},
1873 { "otir", 0xED, 0xB3, emit_insn
},
1874 { "out", 0x00, 0x00, emit_out
},
1875 { "outd", 0xED, 0xAB, emit_insn
},
1876 { "outi", 0xED, 0xA3, emit_insn
},
1877 { "pop", 0x00, 0xC1, emit_pop
},
1878 { "push", 0x00, 0xC5, emit_pop
},
1879 { "res", 0xCB, 0x80, emit_bit
},
1880 { "ret", 0xC9, 0xC0, emit_retcc
},
1881 { "reti", 0xED, 0x4D, emit_insn
},
1882 { "retn", 0xED, 0x45, emit_insn
},
1883 { "rl", 0xCB, 0x10, emit_mr
},
1884 { "rla", 0x00, 0x17, emit_insn
},
1885 { "rlc", 0xCB, 0x00, emit_mr
},
1886 { "rlca", 0x00, 0x07, emit_insn
},
1887 { "rld", 0xED, 0x6F, emit_insn
},
1888 { "rr", 0xCB, 0x18, emit_mr
},
1889 { "rra", 0x00, 0x1F, emit_insn
},
1890 { "rrc", 0xCB, 0x08, emit_mr
},
1891 { "rrca", 0x00, 0x0F, emit_insn
},
1892 { "rrd", 0xED, 0x67, emit_insn
},
1893 { "rst", 0x00, 0xC7, emit_rst
},
1894 { "sbc", 0x98, 0x42, emit_adc
},
1895 { "scf", 0x00, 0x37, emit_insn
},
1896 { "set", 0xCB, 0xC0, emit_bit
},
1897 { "sla", 0xCB, 0x20, emit_mr
},
1898 { "sli", 0xCB, 0x30, emit_mr
},
1899 { "sll", 0xCB, 0x30, emit_mr
},
1900 { "sra", 0xCB, 0x28, emit_mr
},
1901 { "srl", 0xCB, 0x38, emit_mr
},
1902 { "sub", 0x00, 0x90, emit_s
},
1903 { "xor", 0x00, 0xA8, emit_s
},
1907 md_assemble (char* str
)
1915 old_ptr
= input_line_pointer
;
1916 p
= skip_space (str
);
1917 for (i
= 0; (i
< BUFLEN
) && (ISALPHA (*p
));)
1918 buf
[i
++] = TOLOWER (*p
++);
1922 buf
[BUFLEN
-3] = buf
[BUFLEN
-2] = '.'; /* Mark opcode as abbreviated. */
1924 as_bad (_("Unknown instruction '%s'"), buf
);
1926 else if ((*p
) && (!ISSPACE (*p
)))
1927 as_bad (_("syntax error"));
1934 insp
= bsearch (&key
, instab
, ARRAY_SIZE (instab
),
1935 sizeof (instab
[0]), key_cmp
);
1937 as_bad (_("Unknown instruction '%s'"), buf
);
1940 p
= insp
->fp (insp
->prefix
, insp
->opcode
, p
);
1942 if ((!err_flag
) && *p
)
1943 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
1947 input_line_pointer
= old_ptr
;
1951 md_apply_fix (fixS
* fixP
, valueT
* valP
, segT seg ATTRIBUTE_UNUSED
)
1953 long val
= * (long *) valP
;
1954 char *p_lit
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
1956 switch (fixP
->fx_r_type
)
1958 case BFD_RELOC_8_PCREL
:
1961 fixP
->fx_no_overflow
= 1;
1966 fixP
->fx_no_overflow
= (-128 <= val
&& val
< 128);
1967 if (!fixP
->fx_no_overflow
)
1968 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1969 _("relative jump out of range"));
1975 case BFD_RELOC_Z80_DISP8
:
1978 fixP
->fx_no_overflow
= 1;
1983 fixP
->fx_no_overflow
= (-128 <= val
&& val
< 128);
1984 if (!fixP
->fx_no_overflow
)
1985 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1986 _("index offset out of range"));
1993 if (val
> 255 || val
< -128)
1994 as_warn_where (fixP
->fx_file
, fixP
->fx_line
, _("overflow"));
1996 fixP
->fx_no_overflow
= 1;
1997 if (fixP
->fx_addsy
== NULL
)
2003 *p_lit
++ = (val
>> 8);
2004 fixP
->fx_no_overflow
= 1;
2005 if (fixP
->fx_addsy
== NULL
)
2009 case BFD_RELOC_24
: /* Def24 may produce this. */
2011 *p_lit
++ = (val
>> 8);
2012 *p_lit
++ = (val
>> 16);
2013 fixP
->fx_no_overflow
= 1;
2014 if (fixP
->fx_addsy
== NULL
)
2018 case BFD_RELOC_32
: /* Def32 and .long may produce this. */
2020 *p_lit
++ = (val
>> 8);
2021 *p_lit
++ = (val
>> 16);
2022 *p_lit
++ = (val
>> 24);
2023 if (fixP
->fx_addsy
== NULL
)
2028 printf (_("md_apply_fix: unknown r_type 0x%x\n"), fixP
->fx_r_type
);
2033 /* GAS will call this to generate a reloc. GAS will pass the
2034 resulting reloc to `bfd_install_relocation'. This currently works
2035 poorly, as `bfd_install_relocation' often does the wrong thing, and
2036 instances of `tc_gen_reloc' have been written to work around the
2037 problems, which in turns makes it difficult to fix
2038 `bfd_install_relocation'. */
2040 /* If while processing a fixup, a reloc really
2041 needs to be created then it is done here. */
2044 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2048 if (! bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
))
2050 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2051 _("reloc %d not supported by object file format"),
2052 (int) fixp
->fx_r_type
);
2056 reloc
= xmalloc (sizeof (arelent
));
2057 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
2058 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2059 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2060 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
2061 reloc
->addend
= fixp
->fx_offset
;