1 /* tc-z80.c -- Assemble code for the Zilog Z80 and ASCII R800
2 Copyright 2005, 2006, 2007, 2008, 2009, 2012 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)
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)
550 op->X_md = indir = is_indir (p);
551 input_line_pointer = (char*) s ;
552 dummy = expression (op);
556 error (_("missing operand"));
559 error (_("bad expression syntax"));
562 return input_line_pointer;
565 /* Parse expression, change operator to O_md1 for indexed addressing*/
567 parse_exp (const char *s, expressionS *op)
569 const char* res = parse_exp_not_indexed (s, op);
574 if (op->X_md && (O_register == symbol_get_value_expression(op->X_add_symbol)->X_op))
576 int rnum = symbol_get_value_expression(op->X_add_symbol)->X_add_number;
577 if ( ((REG_IX != rnum) && (REG_IY != rnum)) || contains_register(op->X_op_symbol) )
583 if (O_subtract == op->X_op)
586 minus.X_op = O_uminus;
587 minus.X_add_number = 0;
588 minus.X_add_symbol = op->X_op_symbol;
589 minus.X_op_symbol = 0;
590 op->X_op_symbol = make_expr_symbol(&minus);
593 symbol_get_value_expression(op->X_op_symbol)->X_add_number += op->X_add_number;
594 op->X_add_number = rnum;
595 op->X_add_symbol = op->X_op_symbol;
602 if ( op->X_md && ((REG_IX == op->X_add_number)||(REG_IY == op->X_add_number)) )
604 op->X_add_symbol = zero;
612 /* Condition codes, including some synonyms provided by HiTech zas. */
613 static const struct reg_entry cc_tab[] =
631 /* Parse condition code. */
633 parse_cc (const char *s, char * op)
637 struct reg_entry * cc_p;
639 for (i = 0; i < BUFLEN; ++i)
641 if (!ISALPHA (s[i])) /* Condition codes consist of letters only. */
643 buf[i] = TOLOWER (s[i]);
647 && ((s[i] == 0) || (s[i] == ',')))
650 cc_p = bsearch (&key, cc_tab, ARRAY_SIZE (cc_tab),
651 sizeof (cc_tab[0]), key_cmp);
668 emit_insn (char prefix, char opcode, const char * args)
683 void z80_cons_fix_new (fragS *frag_p, int offset, int nbytes, expressionS *exp)
685 bfd_reloc_code_real_type r[4] =
693 if (nbytes < 1 || nbytes > 4)
695 as_bad (_("unsupported BFD relocation size %u"), nbytes);
699 fix_new_exp (frag_p, offset, nbytes, exp, 0, r[nbytes-1]);
704 emit_byte (expressionS * val, bfd_reloc_code_real_type r_type)
711 *p = val->X_add_number;
712 if ( contains_register(val->X_add_symbol) || contains_register(val->X_op_symbol) )
716 else if ((r_type == BFD_RELOC_8_PCREL) && (val->X_op == O_constant))
718 as_bad (_("cannot make a relative jump to an absolute location"));
720 else if (val->X_op == O_constant)
723 hi = (BFD_RELOC_8 == r_type) ? 255 : 127;
725 if ((val->X_add_number < lo) || (val->X_add_number > hi))
727 if (r_type == BFD_RELOC_Z80_DISP8)
728 as_bad (_("offset too large"));
730 as_warn (_("overflow"));
735 fixp = fix_new_exp (frag_now, p - frag_now->fr_literal, 1, val,
736 (r_type == BFD_RELOC_8_PCREL) ? TRUE : FALSE, r_type);
737 /* FIXME : Process constant offsets immediately. */
742 emit_word (expressionS * val)
747 if ( (val->X_op == O_register)
748 || (val->X_op == O_md1)
749 || contains_register(val->X_add_symbol)
750 || contains_register(val->X_op_symbol) )
754 *p = val->X_add_number;
755 p[1] = (val->X_add_number>>8);
756 if (val->X_op != O_constant)
757 fix_new_exp (frag_now, p - frag_now->fr_literal, 2,
758 val, FALSE, BFD_RELOC_16);
763 emit_mx (char prefix, char opcode, int shift, expressionS * arg)
764 /* The operand m may be r, (hl), (ix+d), (iy+d),
765 if 0 == prefix m may also be ixl, ixh, iyl, iyh. */
770 rnum = arg->X_add_number;
786 if ((prefix == 0) && (rnum & R_INDEX))
788 prefix = (rnum & R_IX) ? 0xDD : 0xFD;
789 check_mach (INS_UNDOC);
798 q = frag_more (prefix ? 2 : 1);
801 * q ++ = opcode + (rnum << shift);
805 *q++ = (rnum & R_IX) ? 0xDD : 0xFD;
806 *q = (prefix) ? prefix : (opcode + (6 << shift));
808 expressionS offset = *arg;
809 offset.X_op = O_symbol;
810 offset.X_add_number = 0;
811 emit_byte (&offset, BFD_RELOC_Z80_DISP8);
816 *q = opcode+(6<<shift);
824 /* The operand m may be r, (hl), (ix+d), (iy+d),
825 if 0 = prefix m may also be ixl, ixh, iyl, iyh. */
827 emit_m (char prefix, char opcode, const char *args)
832 p = parse_exp (args, &arg_m);
837 emit_mx (prefix, opcode, 0, &arg_m);
845 /* The operand m may be as above or one of the undocumented
846 combinations (ix+d),r and (iy+d),r (if unportable instructions
849 emit_mr (char prefix, char opcode, const char *args)
851 expressionS arg_m, arg_r;
854 p = parse_exp (args, & arg_m);
861 p = parse_exp (p + 1, & arg_r);
863 if ((arg_r.X_md == 0)
864 && (arg_r.X_op == O_register)
865 && (arg_r.X_add_number < 8))
866 opcode += arg_r.X_add_number-6; /* Emit_mx () will add 6. */
872 check_mach (INS_UNPORT);
875 emit_mx (prefix, opcode, 0, & arg_m);
884 emit_sx (char prefix, char opcode, expressionS * arg_p)
892 emit_mx (prefix, opcode, 0, arg_p);
899 q = frag_more (prefix ? 2 : 1);
903 emit_byte (arg_p, BFD_RELOC_8);
908 /* The operand s may be r, (hl), (ix+d), (iy+d), n. */
910 emit_s (char prefix, char opcode, const char *args)
915 p = parse_exp (args, & arg_s);
916 emit_sx (prefix, opcode, & arg_s);
921 emit_call (char prefix ATTRIBUTE_UNUSED, char opcode, const char * args)
924 const char *p; char *q;
926 p = parse_exp_not_indexed (args, &addr);
938 /* Operand may be rr, r, (hl), (ix+d), (iy+d). */
940 emit_incdec (char prefix, char opcode, const char * args)
944 const char *p; char *q;
946 p = parse_exp (args, &operand);
947 rnum = operand.X_add_number;
949 && (operand.X_op == O_register)
952 q = frag_more ((rnum & R_INDEX) ? 2 : 1);
954 *q++ = (rnum & R_IX) ? 0xDD : 0xFD;
955 *q = prefix + ((rnum & 3) << 4);
959 if ((operand.X_op == O_md1) || (operand.X_op == O_register))
960 emit_mx (0, opcode, 3, & operand);
968 emit_jr (char prefix ATTRIBUTE_UNUSED, char opcode, const char * args)
974 p = parse_exp_not_indexed (args, &addr);
981 emit_byte (&addr, BFD_RELOC_8_PCREL);
987 emit_jp (char prefix, char opcode, const char * args)
994 p = parse_exp_not_indexed (args, & addr);
997 rnum = addr.X_add_number;
998 if ((O_register == addr.X_op) && (REG_HL == (rnum & ~R_INDEX)))
1000 q = frag_more ((rnum & R_INDEX) ? 2 : 1);
1002 *q++ = (rnum & R_IX) ? 0xDD : 0xFD;
1018 emit_im (char prefix, char opcode, const char * args)
1024 p = parse_exp (args, & mode);
1025 if (mode.X_md || (mode.X_op != O_constant))
1028 switch (mode.X_add_number)
1032 ++mode.X_add_number;
1037 *q = opcode + 8*mode.X_add_number;
1046 emit_pop (char prefix ATTRIBUTE_UNUSED, char opcode, const char * args)
1052 p = parse_exp (args, & regp);
1054 && (regp.X_op == O_register)
1055 && (regp.X_add_number & R_STACKABLE))
1059 rnum = regp.X_add_number;
1063 *q++ = (rnum&R_IX)?0xDD:0xFD;
1067 *q = opcode + ((rnum & 3) << 4);
1076 emit_retcc (char prefix ATTRIBUTE_UNUSED, char opcode, const char * args)
1081 p = parse_cc (args, &cc);
1087 return p ? p : args;
1091 emit_adc (char prefix, char opcode, const char * args)
1098 p = parse_exp (args, &term);
1101 error (_("bad instruction syntax"));
1105 if ((term.X_md) || (term.X_op != O_register))
1108 switch (term.X_add_number)
1111 p = emit_s (0, prefix, p);
1114 p = parse_exp (p, &term);
1115 if ((!term.X_md) && (term.X_op == O_register))
1117 rnum = term.X_add_number;
1118 if (R_ARITH == (rnum & (R_ARITH | R_INDEX)))
1122 *q = opcode + ((rnum & 3) << 4);
1134 emit_add (char prefix, char opcode, const char * args)
1141 p = parse_exp (args, &term);
1144 error (_("bad instruction syntax"));
1148 if ((term.X_md) || (term.X_op != O_register))
1151 switch (term.X_add_number & ~R_INDEX)
1154 p = emit_s (0, prefix, p);
1157 lhs = term.X_add_number;
1158 p = parse_exp (p, &term);
1159 if ((!term.X_md) && (term.X_op == O_register))
1161 rhs = term.X_add_number;
1163 && ((rhs == lhs) || ((rhs & ~R_INDEX) != REG_HL)))
1165 q = frag_more ((lhs & R_INDEX) ? 2 : 1);
1167 *q++ = (lhs & R_IX) ? 0xDD : 0xFD;
1168 *q = opcode + ((rhs & 3) << 4);
1180 emit_bit (char prefix, char opcode, const char * args)
1186 p = parse_exp (args, &b);
1188 error (_("bad instruction syntax"));
1190 bn = b.X_add_number;
1192 && (b.X_op == O_constant)
1197 /* Bit : no optional third operand. */
1198 p = emit_m (prefix, opcode + (bn << 3), p);
1200 /* Set, res : resulting byte can be copied to register. */
1201 p = emit_mr (prefix, opcode + (bn << 3), p);
1209 emit_jpcc (char prefix, char opcode, const char * args)
1214 p = parse_cc (args, & cc);
1215 if (p && *p++ == ',')
1216 p = emit_call (0, opcode + cc, p);
1218 p = (prefix == (char)0xC3)
1219 ? emit_jp (0xE9, prefix, args)
1220 : emit_call (0, prefix, args);
1225 emit_jrcc (char prefix, char opcode, const char * args)
1230 p = parse_cc (args, &cc);
1231 if (p && *p++ == ',')
1234 error (_("condition code invalid for jr"));
1236 p = emit_jr (0, opcode + cc, p);
1239 p = emit_jr (0, prefix, args);
1245 emit_ex (char prefix_in ATTRIBUTE_UNUSED,
1246 char opcode_in ATTRIBUTE_UNUSED, const char * args)
1250 char prefix, opcode;
1252 p = parse_exp_not_indexed (args, &op);
1256 error (_("bad instruction syntax"));
1260 prefix = opcode = 0;
1261 if (op.X_op == O_register)
1262 switch (op.X_add_number | (op.X_md ? 0x8000 : 0))
1265 if (TOLOWER (*p++) == 'a' && TOLOWER (*p++) == 'f')
1267 /* The scrubber changes '\'' to '`' in this context. */
1274 if (TOLOWER (*p++) == 'h' && TOLOWER (*p++) == 'l')
1278 p = parse_exp (p, & op);
1279 if (op.X_op == O_register
1281 && (op.X_add_number & ~R_INDEX) == REG_HL)
1284 if (R_INDEX & op.X_add_number)
1285 prefix = (R_IX & op.X_add_number) ? 0xDD : 0xFD;
1290 emit_insn (prefix, opcode, p);
1298 emit_in (char prefix ATTRIBUTE_UNUSED, char opcode ATTRIBUTE_UNUSED,
1301 expressionS reg, port;
1305 p = parse_exp (args, ®);
1308 error (_("bad instruction syntax"));
1312 p = parse_exp (p, &port);
1314 && reg.X_op == O_register
1315 && (reg.X_add_number <= 7 || reg.X_add_number == REG_F)
1318 if (port.X_op != O_md1 && port.X_op != O_register)
1320 if (REG_A == reg.X_add_number)
1324 emit_byte (&port, BFD_RELOC_8);
1331 if (port.X_add_number == REG_C)
1333 if (reg.X_add_number == REG_F)
1334 check_mach (INS_UNDOC);
1339 *q = 0x40|((reg.X_add_number&7)<<3);
1352 emit_out (char prefix ATTRIBUTE_UNUSED, char opcode ATTRIBUTE_UNUSED,
1355 expressionS reg, port;
1359 p = parse_exp (args, & port);
1362 error (_("bad instruction syntax"));
1365 p = parse_exp (p, ®);
1367 { ill_op (); return p; }
1368 /* Allow "out (c), 0" as unportable instruction. */
1369 if (reg.X_op == O_constant && reg.X_add_number == 0)
1371 check_mach (INS_UNPORT);
1372 reg.X_op = O_register;
1373 reg.X_add_number = 6;
1376 || reg.X_op != O_register
1377 || reg.X_add_number > 7)
1380 if (port.X_op != O_register && port.X_op != O_md1)
1382 if (REG_A == reg.X_add_number)
1386 emit_byte (&port, BFD_RELOC_8);
1393 if (REG_C == port.X_add_number)
1397 *q = 0x41 | (reg.X_add_number << 3);
1406 emit_rst (char prefix ATTRIBUTE_UNUSED, char opcode, const char * args)
1412 p = parse_exp_not_indexed (args, &addr);
1413 if (addr.X_op != O_constant)
1415 error ("rst needs constant address");
1419 if (addr.X_add_number & ~(7 << 3))
1424 *q = opcode + (addr.X_add_number & (7 << 3));
1430 emit_ldxhl (char prefix, char opcode, expressionS *src, expressionS *d)
1438 if (src->X_op == O_register)
1440 if (src->X_add_number>7)
1449 *q = opcode + src->X_add_number;
1451 emit_byte (d, BFD_RELOC_Z80_DISP8);
1464 emit_byte (d, BFD_RELOC_Z80_DISP8);
1465 emit_byte (src, BFD_RELOC_8);
1471 emit_ldreg (int dest, expressionS * src)
1478 /* 8 Bit ld group: */
1481 if (src->X_md == 0 && src->X_op == O_register && src->X_add_number == REG_A)
1485 *q = (dest == REG_I) ? 0x47 : 0x4F;
1492 if ((src->X_md) && src->X_op != O_register && src->X_op != O_md1)
1501 && src->X_op == O_register
1502 && (src->X_add_number == REG_BC || src->X_add_number == REG_DE))
1505 *q = 0x0A + ((src->X_add_number & 1) << 4);
1510 && src->X_op == O_register
1511 && (src->X_add_number == REG_R || src->X_add_number == REG_I))
1515 *q = (src->X_add_number == REG_I) ? 0x57 : 0x5F;
1523 emit_sx (0, 0x40 + (dest << 3), src);
1528 if ((src->X_md == 0)
1529 && (src->X_op == O_register)
1530 && (src->X_add_number & R_INDEX))
1533 emit_sx (0, 0x40 + (dest << 3), src);
1545 check_mach (INS_UNDOC);
1546 if (src-> X_op == O_register)
1548 rnum = src->X_add_number;
1549 if ((rnum & ~R_INDEX) < 8
1550 && ((rnum & R_INDEX) == (dest & R_INDEX)
1551 || ( (rnum & ~R_INDEX) != REG_H
1552 && (rnum & ~R_INDEX) != REG_L)))
1555 *q++ = (dest & R_IX) ? 0xDD : 0xFD;
1556 *q = 0x40 + ((dest & 0x07) << 3) + (rnum & 7);
1564 *q++ = (dest & R_IX) ? 0xDD : 0xFD;
1565 *q = 0x06 + ((dest & 0x07) << 3);
1566 emit_byte (src, BFD_RELOC_8);
1570 /* 16 Bit ld group: */
1573 && src->X_op == O_register
1574 && REG_HL == (src->X_add_number &~ R_INDEX))
1576 q = frag_more ((src->X_add_number & R_INDEX) ? 2 : 1);
1577 if (src->X_add_number & R_INDEX)
1578 *q++ = (src->X_add_number & R_IX) ? 0xDD : 0xFD;
1585 if (src->X_op == O_register || src->X_op == O_md1)
1587 q = frag_more (src->X_md ? 2 : 1);
1591 *q = 0x4B + ((dest & 3) << 4);
1594 *q = 0x01 + ((dest & 3) << 4);
1601 if (src->X_op == O_register || src->X_op == O_md1)
1603 q = frag_more ((dest & R_INDEX) ? 2 : 1);
1605 * q ++ = (dest & R_IX) ? 0xDD : 0xFD;
1606 *q = (src->X_md) ? 0x2A : 0x21;
1621 emit_ld (char prefix_in ATTRIBUTE_UNUSED, char opcode_in ATTRIBUTE_UNUSED,
1624 expressionS dst, src;
1627 char prefix, opcode;
1629 p = parse_exp (args, &dst);
1631 error (_("bad instruction syntax"));
1632 p = parse_exp (p, &src);
1638 expressionS dst_offset = dst;
1639 dst_offset.X_op = O_symbol;
1640 dst_offset.X_add_number = 0;
1641 emit_ldxhl ((dst.X_add_number & R_IX) ? 0xDD : 0xFD, 0x70,
1649 switch (dst.X_add_number)
1653 if (src.X_md == 0 && src.X_op == O_register && src.X_add_number == REG_A)
1656 *q = 0x02 + ( (dst.X_add_number & 1) << 4);
1662 emit_ldxhl (0, 0x70, &src, NULL);
1669 emit_ldreg (dst.X_add_number, &src);
1673 if (src.X_md != 0 || src.X_op != O_register)
1675 prefix = opcode = 0;
1676 switch (src.X_add_number)
1679 opcode = 0x32; break;
1680 case REG_BC: case REG_DE: case REG_SP:
1681 prefix = 0xED; opcode = 0x43 + ((src.X_add_number&3)<<4); break;
1683 opcode = 0x22; break;
1685 prefix = 0xDD; opcode = 0x22; break;
1687 prefix = 0xFD; opcode = 0x22; break;
1691 q = frag_more (prefix?2:1);
1704 emit_data (int size ATTRIBUTE_UNUSED)
1711 if (is_it_end_of_statement ())
1713 demand_empty_rest_of_line ();
1716 p = skip_space (input_line_pointer);
1720 if (*p == '\"' || *p == '\'')
1722 for (quote = *p, q = ++p, cnt = 0; *p && quote != *p; ++p, ++cnt)
1724 u = frag_more (cnt);
1727 as_warn (_("unterminated string"));
1729 p = skip_space (p+1);
1733 p = parse_exp (p, &exp);
1734 if (exp.X_op == O_md1 || exp.X_op == O_register)
1740 as_warn (_("parentheses ignored"));
1741 emit_byte (&exp, BFD_RELOC_8);
1745 while (*p++ == ',') ;
1746 input_line_pointer = (char *)(p-1);
1750 emit_mulub (char prefix ATTRIBUTE_UNUSED, char opcode, const char * args)
1754 p = skip_space (args);
1755 if (TOLOWER (*p++) != 'a' || *p++ != ',')
1761 reg = TOLOWER (*p++);
1768 check_mach (INS_R800);
1769 if (!*skip_space (p))
1773 *q = opcode + ((reg - 'b') << 3);
1784 emit_muluw (char prefix ATTRIBUTE_UNUSED, char opcode, const char * args)
1788 p = skip_space (args);
1789 if (TOLOWER (*p++) != 'h' || TOLOWER (*p++) != 'l' || *p++ != ',')
1796 p = parse_exp (p, & reg);
1798 if ((!reg.X_md) && reg.X_op == O_register)
1799 switch (reg.X_add_number)
1803 check_mach (INS_R800);
1806 *q = opcode + ((reg.X_add_number & 3) << 4);
1815 /* Port specific pseudo ops. */
1816 const pseudo_typeS md_pseudo_table[] =
1818 { "db" , emit_data, 1},
1821 { "def24", cons, 3},
1822 { "def32", cons, 4},
1823 { "defb", emit_data, 1},
1824 { "defs", s_space, 1}, /* Synonym for ds on some assemblers. */
1826 { "ds", s_space, 1}, /* Fill with bytes rather than words. */
1828 { "psect", obj_coff_section, 0}, /* TODO: Translate attributes. */
1829 { "set", 0, 0}, /* Real instruction on z80. */
1833 static table_t instab[] =
1835 { "adc", 0x88, 0x4A, emit_adc },
1836 { "add", 0x80, 0x09, emit_add },
1837 { "and", 0x00, 0xA0, emit_s },
1838 { "bit", 0xCB, 0x40, emit_bit },
1839 { "call", 0xCD, 0xC4, emit_jpcc },
1840 { "ccf", 0x00, 0x3F, emit_insn },
1841 { "cp", 0x00, 0xB8, emit_s },
1842 { "cpd", 0xED, 0xA9, emit_insn },
1843 { "cpdr", 0xED, 0xB9, emit_insn },
1844 { "cpi", 0xED, 0xA1, emit_insn },
1845 { "cpir", 0xED, 0xB1, emit_insn },
1846 { "cpl", 0x00, 0x2F, emit_insn },
1847 { "daa", 0x00, 0x27, emit_insn },
1848 { "dec", 0x0B, 0x05, emit_incdec },
1849 { "di", 0x00, 0xF3, emit_insn },
1850 { "djnz", 0x00, 0x10, emit_jr },
1851 { "ei", 0x00, 0xFB, emit_insn },
1852 { "ex", 0x00, 0x00, emit_ex},
1853 { "exx", 0x00, 0xD9, emit_insn },
1854 { "halt", 0x00, 0x76, emit_insn },
1855 { "im", 0xED, 0x46, emit_im },
1856 { "in", 0x00, 0x00, emit_in },
1857 { "inc", 0x03, 0x04, emit_incdec },
1858 { "ind", 0xED, 0xAA, emit_insn },
1859 { "indr", 0xED, 0xBA, emit_insn },
1860 { "ini", 0xED, 0xA2, emit_insn },
1861 { "inir", 0xED, 0xB2, emit_insn },
1862 { "jp", 0xC3, 0xC2, emit_jpcc },
1863 { "jr", 0x18, 0x20, emit_jrcc },
1864 { "ld", 0x00, 0x00, emit_ld },
1865 { "ldd", 0xED, 0xA8, emit_insn },
1866 { "lddr", 0xED, 0xB8, emit_insn },
1867 { "ldi", 0xED, 0xA0, emit_insn },
1868 { "ldir", 0xED, 0xB0, emit_insn },
1869 { "mulub", 0xED, 0xC5, emit_mulub }, /* R800 only. */
1870 { "muluw", 0xED, 0xC3, emit_muluw }, /* R800 only. */
1871 { "neg", 0xed, 0x44, emit_insn },
1872 { "nop", 0x00, 0x00, emit_insn },
1873 { "or", 0x00, 0xB0, emit_s },
1874 { "otdr", 0xED, 0xBB, emit_insn },
1875 { "otir", 0xED, 0xB3, emit_insn },
1876 { "out", 0x00, 0x00, emit_out },
1877 { "outd", 0xED, 0xAB, emit_insn },
1878 { "outi", 0xED, 0xA3, emit_insn },
1879 { "pop", 0x00, 0xC1, emit_pop },
1880 { "push", 0x00, 0xC5, emit_pop },
1881 { "res", 0xCB, 0x80, emit_bit },
1882 { "ret", 0xC9, 0xC0, emit_retcc },
1883 { "reti", 0xED, 0x4D, emit_insn },
1884 { "retn", 0xED, 0x45, emit_insn },
1885 { "rl", 0xCB, 0x10, emit_mr },
1886 { "rla", 0x00, 0x17, emit_insn },
1887 { "rlc", 0xCB, 0x00, emit_mr },
1888 { "rlca", 0x00, 0x07, emit_insn },
1889 { "rld", 0xED, 0x6F, emit_insn },
1890 { "rr", 0xCB, 0x18, emit_mr },
1891 { "rra", 0x00, 0x1F, emit_insn },
1892 { "rrc", 0xCB, 0x08, emit_mr },
1893 { "rrca", 0x00, 0x0F, emit_insn },
1894 { "rrd", 0xED, 0x67, emit_insn },
1895 { "rst", 0x00, 0xC7, emit_rst},
1896 { "sbc", 0x98, 0x42, emit_adc },
1897 { "scf", 0x00, 0x37, emit_insn },
1898 { "set", 0xCB, 0xC0, emit_bit },
1899 { "sla", 0xCB, 0x20, emit_mr },
1900 { "sli", 0xCB, 0x30, emit_mr },
1901 { "sll", 0xCB, 0x30, emit_mr },
1902 { "sra", 0xCB, 0x28, emit_mr },
1903 { "srl", 0xCB, 0x38, emit_mr },
1904 { "sub", 0x00, 0x90, emit_s },
1905 { "xor", 0x00, 0xA8, emit_s },
1909 md_assemble (char* str)
1917 old_ptr = input_line_pointer;
1918 p = skip_space (str);
1919 for (i = 0; (i < BUFLEN) && (ISALPHA (*p));)
1920 buf[i++] = TOLOWER (*p++);
1924 buf[BUFLEN-3] = buf[BUFLEN-2] = '.'; /* Mark opcode as abbreviated. */
1926 as_bad (_("Unknown instruction '%s'"), buf);
1928 else if ((*p) && (!ISSPACE (*p)))
1929 as_bad (_("syntax error"));
1936 insp = bsearch (&key, instab, ARRAY_SIZE (instab),
1937 sizeof (instab[0]), key_cmp);
1939 as_bad (_("Unknown instruction '%s'"), buf);
1942 p = insp->fp (insp->prefix, insp->opcode, p);
1944 if ((!err_flag) && *p)
1945 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
1949 input_line_pointer = old_ptr;
1953 md_apply_fix (fixS * fixP, valueT* valP, segT seg ATTRIBUTE_UNUSED)
1955 long val = * (long *) valP;
1956 char *p_lit = fixP->fx_where + fixP->fx_frag->fr_literal;
1958 switch (fixP->fx_r_type)
1960 case BFD_RELOC_8_PCREL:
1963 fixP->fx_no_overflow = 1;
1968 fixP->fx_no_overflow = (-128 <= val && val < 128);
1969 if (!fixP->fx_no_overflow)
1970 as_bad_where (fixP->fx_file, fixP->fx_line,
1971 _("relative jump out of range"));
1977 case BFD_RELOC_Z80_DISP8:
1980 fixP->fx_no_overflow = 1;
1985 fixP->fx_no_overflow = (-128 <= val && val < 128);
1986 if (!fixP->fx_no_overflow)
1987 as_bad_where (fixP->fx_file, fixP->fx_line,
1988 _("index offset out of range"));
1995 if (val > 255 || val < -128)
1996 as_warn_where (fixP->fx_file, fixP->fx_line, _("overflow"));
1998 fixP->fx_no_overflow = 1;
1999 if (fixP->fx_addsy == NULL)
2005 *p_lit++ = (val >> 8);
2006 fixP->fx_no_overflow = 1;
2007 if (fixP->fx_addsy == NULL)
2011 case BFD_RELOC_24: /* Def24 may produce this. */
2013 *p_lit++ = (val >> 8);
2014 *p_lit++ = (val >> 16);
2015 fixP->fx_no_overflow = 1;
2016 if (fixP->fx_addsy == NULL)
2020 case BFD_RELOC_32: /* Def32 and .long may produce this. */
2022 *p_lit++ = (val >> 8);
2023 *p_lit++ = (val >> 16);
2024 *p_lit++ = (val >> 24);
2025 if (fixP->fx_addsy == NULL)
2030 printf (_("md_apply_fix: unknown r_type 0x%x\n"), fixP->fx_r_type);
2035 /* GAS will call this to generate a reloc. GAS will pass the
2036 resulting reloc to `bfd_install_relocation'. This currently works
2037 poorly, as `bfd_install_relocation' often does the wrong thing, and
2038 instances of `tc_gen_reloc' have been written to work around the
2039 problems, which in turns makes it difficult to fix
2040 `bfd_install_relocation'. */
2042 /* If while processing a fixup, a reloc really
2043 needs to be created then it is done here. */
2046 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED , fixS *fixp)
2050 if (! bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type))
2052 as_bad_where (fixp->fx_file, fixp->fx_line,
2053 _("reloc %d not supported by object file format"),
2054 (int) fixp->fx_r_type);
2058 reloc = xmalloc (sizeof (arelent));
2059 reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
2060 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2061 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2062 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2063 reloc->addend = fixp->fx_offset;