cgen-asm.in revision 130561
1/* Assembler interface for targets using CGEN. -*- C -*- 2 CGEN: Cpu tools GENerator 3 4THIS FILE IS MACHINE GENERATED WITH CGEN. 5- the resultant file is machine generated, cgen-asm.in isn't 6 7Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. 8 9This file is part of the GNU Binutils and GDB, the GNU debugger. 10 11This program is free software; you can redistribute it and/or modify 12it under the terms of the GNU General Public License as published by 13the Free Software Foundation; either version 2, or (at your option) 14any later version. 15 16This program is distributed in the hope that it will be useful, 17but WITHOUT ANY WARRANTY; without even the implied warranty of 18MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19GNU General Public License for more details. 20 21You should have received a copy of the GNU General Public License 22along with this program; if not, write to the Free Software Foundation, Inc., 2359 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 24 25/* ??? Eventually more and more of this stuff can go to cpu-independent files. 26 Keep that in mind. */ 27 28#include "sysdep.h" 29#include <stdio.h> 30#include "ansidecl.h" 31#include "bfd.h" 32#include "symcat.h" 33#include "@prefix@-desc.h" 34#include "@prefix@-opc.h" 35#include "opintl.h" 36#include "xregex.h" 37#include "libiberty.h" 38#include "safe-ctype.h" 39 40#undef min 41#define min(a,b) ((a) < (b) ? (a) : (b)) 42#undef max 43#define max(a,b) ((a) > (b) ? (a) : (b)) 44 45static const char * parse_insn_normal 46 (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *); 47 48/* -- assembler routines inserted here. */ 49 50 51/* Regex construction routine. 52 53 This translates an opcode syntax string into a regex string, 54 by replacing any non-character syntax element (such as an 55 opcode) with the pattern '.*' 56 57 It then compiles the regex and stores it in the opcode, for 58 later use by @arch@_cgen_assemble_insn 59 60 Returns NULL for success, an error message for failure. */ 61 62char * 63@arch@_cgen_build_insn_regex (CGEN_INSN *insn) 64{ 65 CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn); 66 const char *mnem = CGEN_INSN_MNEMONIC (insn); 67 char rxbuf[CGEN_MAX_RX_ELEMENTS]; 68 char *rx = rxbuf; 69 const CGEN_SYNTAX_CHAR_TYPE *syn; 70 int reg_err; 71 72 syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc)); 73 74 /* Mnemonics come first in the syntax string. */ 75 if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) 76 return _("missing mnemonic in syntax string"); 77 ++syn; 78 79 /* Generate a case sensitive regular expression that emulates case 80 insensitive matching in the "C" locale. We cannot generate a case 81 insensitive regular expression because in Turkish locales, 'i' and 'I' 82 are not equal modulo case conversion. */ 83 84 /* Copy the literal mnemonic out of the insn. */ 85 for (; *mnem; mnem++) 86 { 87 char c = *mnem; 88 89 if (ISALPHA (c)) 90 { 91 *rx++ = '['; 92 *rx++ = TOLOWER (c); 93 *rx++ = TOUPPER (c); 94 *rx++ = ']'; 95 } 96 else 97 *rx++ = c; 98 } 99 100 /* Copy any remaining literals from the syntax string into the rx. */ 101 for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn) 102 { 103 if (CGEN_SYNTAX_CHAR_P (* syn)) 104 { 105 char c = CGEN_SYNTAX_CHAR (* syn); 106 107 switch (c) 108 { 109 /* Escape any regex metacharacters in the syntax. */ 110 case '.': case '[': case '\\': 111 case '*': case '^': case '$': 112 113#ifdef CGEN_ESCAPE_EXTENDED_REGEX 114 case '?': case '{': case '}': 115 case '(': case ')': case '*': 116 case '|': case '+': case ']': 117#endif 118 *rx++ = '\\'; 119 *rx++ = c; 120 break; 121 122 default: 123 if (ISALPHA (c)) 124 { 125 *rx++ = '['; 126 *rx++ = TOLOWER (c); 127 *rx++ = TOUPPER (c); 128 *rx++ = ']'; 129 } 130 else 131 *rx++ = c; 132 break; 133 } 134 } 135 else 136 { 137 /* Replace non-syntax fields with globs. */ 138 *rx++ = '.'; 139 *rx++ = '*'; 140 } 141 } 142 143 /* Trailing whitespace ok. */ 144 * rx++ = '['; 145 * rx++ = ' '; 146 * rx++ = '\t'; 147 * rx++ = ']'; 148 * rx++ = '*'; 149 150 /* But anchor it after that. */ 151 * rx++ = '$'; 152 * rx = '\0'; 153 154 CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t)); 155 reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB); 156 157 if (reg_err == 0) 158 return NULL; 159 else 160 { 161 static char msg[80]; 162 163 regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80); 164 regfree ((regex_t *) CGEN_INSN_RX (insn)); 165 free (CGEN_INSN_RX (insn)); 166 (CGEN_INSN_RX (insn)) = NULL; 167 return msg; 168 } 169} 170 171 172/* Default insn parser. 173 174 The syntax string is scanned and operands are parsed and stored in FIELDS. 175 Relocs are queued as we go via other callbacks. 176 177 ??? Note that this is currently an all-or-nothing parser. If we fail to 178 parse the instruction, we return 0 and the caller will start over from 179 the beginning. Backtracking will be necessary in parsing subexpressions, 180 but that can be handled there. Not handling backtracking here may get 181 expensive in the case of the m68k. Deal with later. 182 183 Returns NULL for success, an error message for failure. */ 184 185static const char * 186parse_insn_normal (CGEN_CPU_DESC cd, 187 const CGEN_INSN *insn, 188 const char **strp, 189 CGEN_FIELDS *fields) 190{ 191 /* ??? Runtime added insns not handled yet. */ 192 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 193 const char *str = *strp; 194 const char *errmsg; 195 const char *p; 196 const CGEN_SYNTAX_CHAR_TYPE * syn; 197#ifdef CGEN_MNEMONIC_OPERANDS 198 /* FIXME: wip */ 199 int past_opcode_p; 200#endif 201 202 /* For now we assume the mnemonic is first (there are no leading operands). 203 We can parse it without needing to set up operand parsing. 204 GAS's input scrubber will ensure mnemonics are lowercase, but we may 205 not be called from GAS. */ 206 p = CGEN_INSN_MNEMONIC (insn); 207 while (*p && TOLOWER (*p) == TOLOWER (*str)) 208 ++p, ++str; 209 210 if (* p) 211 return _("unrecognized instruction"); 212 213#ifndef CGEN_MNEMONIC_OPERANDS 214 if (* str && ! ISSPACE (* str)) 215 return _("unrecognized instruction"); 216#endif 217 218 CGEN_INIT_PARSE (cd); 219 cgen_init_parse_operand (cd); 220#ifdef CGEN_MNEMONIC_OPERANDS 221 past_opcode_p = 0; 222#endif 223 224 /* We don't check for (*str != '\0') here because we want to parse 225 any trailing fake arguments in the syntax string. */ 226 syn = CGEN_SYNTAX_STRING (syntax); 227 228 /* Mnemonics come first for now, ensure valid string. */ 229 if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) 230 abort (); 231 232 ++syn; 233 234 while (* syn != 0) 235 { 236 /* Non operand chars must match exactly. */ 237 if (CGEN_SYNTAX_CHAR_P (* syn)) 238 { 239 /* FIXME: While we allow for non-GAS callers above, we assume the 240 first char after the mnemonic part is a space. */ 241 /* FIXME: We also take inappropriate advantage of the fact that 242 GAS's input scrubber will remove extraneous blanks. */ 243 if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn))) 244 { 245#ifdef CGEN_MNEMONIC_OPERANDS 246 if (CGEN_SYNTAX_CHAR(* syn) == ' ') 247 past_opcode_p = 1; 248#endif 249 ++ syn; 250 ++ str; 251 } 252 else if (*str) 253 { 254 /* Syntax char didn't match. Can't be this insn. */ 255 static char msg [80]; 256 257 /* xgettext:c-format */ 258 sprintf (msg, _("syntax error (expected char `%c', found `%c')"), 259 CGEN_SYNTAX_CHAR(*syn), *str); 260 return msg; 261 } 262 else 263 { 264 /* Ran out of input. */ 265 static char msg [80]; 266 267 /* xgettext:c-format */ 268 sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"), 269 CGEN_SYNTAX_CHAR(*syn)); 270 return msg; 271 } 272 continue; 273 } 274 275 /* We have an operand of some sort. */ 276 errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), 277 &str, fields); 278 if (errmsg) 279 return errmsg; 280 281 /* Done with this operand, continue with next one. */ 282 ++ syn; 283 } 284 285 /* If we're at the end of the syntax string, we're done. */ 286 if (* syn == 0) 287 { 288 /* FIXME: For the moment we assume a valid `str' can only contain 289 blanks now. IE: We needn't try again with a longer version of 290 the insn and it is assumed that longer versions of insns appear 291 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */ 292 while (ISSPACE (* str)) 293 ++ str; 294 295 if (* str != '\0') 296 return _("junk at end of line"); /* FIXME: would like to include `str' */ 297 298 return NULL; 299 } 300 301 /* We couldn't parse it. */ 302 return _("unrecognized instruction"); 303} 304 305/* Main entry point. 306 This routine is called for each instruction to be assembled. 307 STR points to the insn to be assembled. 308 We assume all necessary tables have been initialized. 309 The assembled instruction, less any fixups, is stored in BUF. 310 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value 311 still needs to be converted to target byte order, otherwise BUF is an array 312 of bytes in target byte order. 313 The result is a pointer to the insn's entry in the opcode table, 314 or NULL if an error occured (an error message will have already been 315 printed). 316 317 Note that when processing (non-alias) macro-insns, 318 this function recurses. 319 320 ??? It's possible to make this cpu-independent. 321 One would have to deal with a few minor things. 322 At this point in time doing so would be more of a curiosity than useful 323 [for example this file isn't _that_ big], but keeping the possibility in 324 mind helps keep the design clean. */ 325 326const CGEN_INSN * 327@arch@_cgen_assemble_insn (CGEN_CPU_DESC cd, 328 const char *str, 329 CGEN_FIELDS *fields, 330 CGEN_INSN_BYTES_PTR buf, 331 char **errmsg) 332{ 333 const char *start; 334 CGEN_INSN_LIST *ilist; 335 const char *parse_errmsg = NULL; 336 const char *insert_errmsg = NULL; 337 int recognized_mnemonic = 0; 338 339 /* Skip leading white space. */ 340 while (ISSPACE (* str)) 341 ++ str; 342 343 /* The instructions are stored in hashed lists. 344 Get the first in the list. */ 345 ilist = CGEN_ASM_LOOKUP_INSN (cd, str); 346 347 /* Keep looking until we find a match. */ 348 start = str; 349 for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist)) 350 { 351 const CGEN_INSN *insn = ilist->insn; 352 recognized_mnemonic = 1; 353 354#ifdef CGEN_VALIDATE_INSN_SUPPORTED 355 /* Not usually needed as unsupported opcodes 356 shouldn't be in the hash lists. */ 357 /* Is this insn supported by the selected cpu? */ 358 if (! @arch@_cgen_insn_supported (cd, insn)) 359 continue; 360#endif 361 /* If the RELAXED attribute is set, this is an insn that shouldn't be 362 chosen immediately. Instead, it is used during assembler/linker 363 relaxation if possible. */ 364 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0) 365 continue; 366 367 str = start; 368 369 /* Skip this insn if str doesn't look right lexically. */ 370 if (CGEN_INSN_RX (insn) != NULL && 371 regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH) 372 continue; 373 374 /* Allow parse/insert handlers to obtain length of insn. */ 375 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn); 376 377 parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields); 378 if (parse_errmsg != NULL) 379 continue; 380 381 /* ??? 0 is passed for `pc'. */ 382 insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf, 383 (bfd_vma) 0); 384 if (insert_errmsg != NULL) 385 continue; 386 387 /* It is up to the caller to actually output the insn and any 388 queued relocs. */ 389 return insn; 390 } 391 392 { 393 static char errbuf[150]; 394#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS 395 const char *tmp_errmsg; 396 397 /* If requesting verbose error messages, use insert_errmsg. 398 Failing that, use parse_errmsg. */ 399 tmp_errmsg = (insert_errmsg ? insert_errmsg : 400 parse_errmsg ? parse_errmsg : 401 recognized_mnemonic ? 402 _("unrecognized form of instruction") : 403 _("unrecognized instruction")); 404 405 if (strlen (start) > 50) 406 /* xgettext:c-format */ 407 sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start); 408 else 409 /* xgettext:c-format */ 410 sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start); 411#else 412 if (strlen (start) > 50) 413 /* xgettext:c-format */ 414 sprintf (errbuf, _("bad instruction `%.50s...'"), start); 415 else 416 /* xgettext:c-format */ 417 sprintf (errbuf, _("bad instruction `%.50s'"), start); 418#endif 419 420 *errmsg = errbuf; 421 return NULL; 422 } 423} 424 425#if 0 /* This calls back to GAS which we can't do without care. */ 426 427/* Record each member of OPVALS in the assembler's symbol table. 428 This lets GAS parse registers for us. 429 ??? Interesting idea but not currently used. */ 430 431/* Record each member of OPVALS in the assembler's symbol table. 432 FIXME: Not currently used. */ 433 434void 435@arch@_cgen_asm_hash_keywords (CGEN_CPU_DESC cd, CGEN_KEYWORD *opvals) 436{ 437 CGEN_KEYWORD_SEARCH search = cgen_keyword_search_init (opvals, NULL); 438 const CGEN_KEYWORD_ENTRY * ke; 439 440 while ((ke = cgen_keyword_search_next (& search)) != NULL) 441 { 442#if 0 /* Unnecessary, should be done in the search routine. */ 443 if (! @arch@_cgen_opval_supported (ke)) 444 continue; 445#endif 446 cgen_asm_record_register (cd, ke->name, ke->value); 447 } 448} 449 450#endif /* 0 */ 451