1 /* CGEN generic assembler support code. 2 3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 4 Free Software Foundation, Inc. 5 6 This file is part of the GNU Binutils and GDB, the GNU debugger. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2, or (at your option) 11 any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License along 19 with this program; if not, write to the Free Software Foundation, Inc., 20 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include <stdio.h> 24 #include "ansidecl.h" 25 #include "libiberty.h" 26 #include "safe-ctype.h" 27 #include "bfd.h" 28 #include "symcat.h" 29 #include "opcode/cgen.h" 30 #include "opintl.h" 31 32 static CGEN_INSN_LIST * hash_insn_array (CGEN_CPU_DESC, const CGEN_INSN *, int, int, CGEN_INSN_LIST **, CGEN_INSN_LIST *); 33 static CGEN_INSN_LIST * hash_insn_list (CGEN_CPU_DESC, const CGEN_INSN_LIST *, CGEN_INSN_LIST **, CGEN_INSN_LIST *); 34 static void build_asm_hash_table (CGEN_CPU_DESC); 35 36 /* Set the cgen_parse_operand_fn callback. */ 37 38 void 39 cgen_set_parse_operand_fn (CGEN_CPU_DESC cd, cgen_parse_operand_fn fn) 40 { 41 cd->parse_operand_fn = fn; 42 } 43 44 /* Called whenever starting to parse an insn. */ 45 46 void 47 cgen_init_parse_operand (CGEN_CPU_DESC cd) 48 { 49 /* This tells the callback to re-initialize. */ 50 (void) (* cd->parse_operand_fn) 51 (cd, CGEN_PARSE_OPERAND_INIT, NULL, 0, 0, NULL, NULL); 52 } 53 54 /* Subroutine of build_asm_hash_table to add INSNS to the hash table. 55 56 COUNT is the number of elements in INSNS. 57 ENTSIZE is sizeof (CGEN_IBASE) for the target. 58 ??? No longer used but leave in for now. 59 HTABLE points to the hash table. 60 HENTBUF is a pointer to sufficiently large buffer of hash entries. 61 The result is a pointer to the next entry to use. 62 63 The table is scanned backwards as additions are made to the front of the 64 list and we want earlier ones to be prefered. */ 65 66 static CGEN_INSN_LIST * 67 hash_insn_array (CGEN_CPU_DESC cd, 68 const CGEN_INSN *insns, 69 int count, 70 int entsize ATTRIBUTE_UNUSED, 71 CGEN_INSN_LIST **htable, 72 CGEN_INSN_LIST *hentbuf) 73 { 74 int i; 75 76 for (i = count - 1; i >= 0; --i, ++hentbuf) 77 { 78 unsigned int hash; 79 const CGEN_INSN *insn = &insns[i]; 80 81 if (! (* cd->asm_hash_p) (insn)) 82 continue; 83 hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (insn)); 84 hentbuf->next = htable[hash]; 85 hentbuf->insn = insn; 86 htable[hash] = hentbuf; 87 } 88 89 return hentbuf; 90 } 91 92 /* Subroutine of build_asm_hash_table to add INSNS to the hash table. 93 This function is identical to hash_insn_array except the insns are 94 in a list. */ 95 96 static CGEN_INSN_LIST * 97 hash_insn_list (CGEN_CPU_DESC cd, 98 const CGEN_INSN_LIST *insns, 99 CGEN_INSN_LIST **htable, 100 CGEN_INSN_LIST *hentbuf) 101 { 102 const CGEN_INSN_LIST *ilist; 103 104 for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf) 105 { 106 unsigned int hash; 107 108 if (! (* cd->asm_hash_p) (ilist->insn)) 109 continue; 110 hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (ilist->insn)); 111 hentbuf->next = htable[hash]; 112 hentbuf->insn = ilist->insn; 113 htable[hash] = hentbuf; 114 } 115 116 return hentbuf; 117 } 118 119 /* Build the assembler instruction hash table. */ 120 121 static void 122 build_asm_hash_table (CGEN_CPU_DESC cd) 123 { 124 int count = cgen_insn_count (cd) + cgen_macro_insn_count (cd); 125 CGEN_INSN_TABLE *insn_table = &cd->insn_table; 126 CGEN_INSN_TABLE *macro_insn_table = &cd->macro_insn_table; 127 unsigned int hash_size = cd->asm_hash_size; 128 CGEN_INSN_LIST *hash_entry_buf; 129 CGEN_INSN_LIST **asm_hash_table; 130 CGEN_INSN_LIST *asm_hash_table_entries; 131 132 /* The space allocated for the hash table consists of two parts: 133 the hash table and the hash lists. */ 134 135 asm_hash_table = (CGEN_INSN_LIST **) 136 xmalloc (hash_size * sizeof (CGEN_INSN_LIST *)); 137 memset (asm_hash_table, 0, hash_size * sizeof (CGEN_INSN_LIST *)); 138 asm_hash_table_entries = hash_entry_buf = (CGEN_INSN_LIST *) 139 xmalloc (count * sizeof (CGEN_INSN_LIST)); 140 141 /* Add compiled in insns. 142 Don't include the first one as it is a reserved entry. */ 143 /* ??? It was the end of all hash chains, and also the special 144 "invalid insn" marker. May be able to do it differently now. */ 145 146 hash_entry_buf = hash_insn_array (cd, 147 insn_table->init_entries + 1, 148 insn_table->num_init_entries - 1, 149 insn_table->entry_size, 150 asm_hash_table, hash_entry_buf); 151 152 /* Add compiled in macro-insns. */ 153 154 hash_entry_buf = hash_insn_array (cd, macro_insn_table->init_entries, 155 macro_insn_table->num_init_entries, 156 macro_insn_table->entry_size, 157 asm_hash_table, hash_entry_buf); 158 159 /* Add runtime added insns. 160 Later added insns will be prefered over earlier ones. */ 161 162 hash_entry_buf = hash_insn_list (cd, insn_table->new_entries, 163 asm_hash_table, hash_entry_buf); 164 165 /* Add runtime added macro-insns. */ 166 167 hash_insn_list (cd, macro_insn_table->new_entries, 168 asm_hash_table, hash_entry_buf); 169 170 cd->asm_hash_table = asm_hash_table; 171 cd->asm_hash_table_entries = asm_hash_table_entries; 172 } 173 174 /* Return the first entry in the hash list for INSN. */ 175 176 CGEN_INSN_LIST * 177 cgen_asm_lookup_insn (CGEN_CPU_DESC cd, const char *insn) 178 { 179 unsigned int hash; 180 181 if (cd->asm_hash_table == NULL) 182 build_asm_hash_table (cd); 183 184 hash = (* cd->asm_hash) (insn); 185 return cd->asm_hash_table[hash]; 186 } 187 188 /* Keyword parser. 189 The result is NULL upon success or an error message. 190 If successful, *STRP is updated to point passed the keyword. 191 192 ??? At present we have a static notion of how to pick out a keyword. 193 Later we can allow a target to customize this if necessary [say by 194 recording something in the keyword table]. */ 195 196 const char * 197 cgen_parse_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 198 const char **strp, 199 CGEN_KEYWORD *keyword_table, 200 long *valuep) 201 { 202 const CGEN_KEYWORD_ENTRY *ke; 203 char buf[256]; 204 const char *p,*start; 205 206 if (keyword_table->name_hash_table == NULL) 207 (void) cgen_keyword_search_init (keyword_table, NULL); 208 209 p = start = *strp; 210 211 /* Allow any first character. This is to make life easier for 212 the fairly common case of suffixes, eg. 'ld.b.w', where the first 213 character of the suffix ('.') is special. */ 214 if (*p) 215 ++p; 216 217 /* Allow letters, digits, and any special characters. */ 218 while (((p - start) < (int) sizeof (buf)) 219 && *p 220 && (ISALNUM (*p) 221 || *p == '_' 222 || strchr (keyword_table->nonalpha_chars, *p))) 223 ++p; 224 225 if (p - start >= (int) sizeof (buf)) 226 { 227 /* All non-empty CGEN keywords can fit into BUF. The only thing 228 we can match here is the empty keyword. */ 229 buf[0] = 0; 230 } 231 else 232 { 233 memcpy (buf, start, p - start); 234 buf[p - start] = 0; 235 } 236 237 ke = cgen_keyword_lookup_name (keyword_table, buf); 238 239 if (ke != NULL) 240 { 241 *valuep = ke->value; 242 /* Don't advance pointer if we recognized the null keyword. */ 243 if (ke->name[0] != 0) 244 *strp = p; 245 return NULL; 246 } 247 248 return "unrecognized keyword/register name"; 249 } 250 251 /* Parse a small signed integer parser. 252 ??? VALUEP is not a bfd_vma * on purpose, though this is confusing. 253 Note that if the caller expects a bfd_vma result, it should call 254 cgen_parse_address. */ 255 256 const char * 257 cgen_parse_signed_integer (CGEN_CPU_DESC cd, 258 const char **strp, 259 int opindex, 260 long *valuep) 261 { 262 bfd_vma value; 263 enum cgen_parse_operand_result result; 264 const char *errmsg; 265 266 errmsg = (* cd->parse_operand_fn) 267 (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE, 268 &result, &value); 269 /* FIXME: Examine `result'. */ 270 if (!errmsg) 271 *valuep = value; 272 return errmsg; 273 } 274 275 /* Parse a small unsigned integer parser. 276 ??? VALUEP is not a bfd_vma * on purpose, though this is confusing. 277 Note that if the caller expects a bfd_vma result, it should call 278 cgen_parse_address. */ 279 280 const char * 281 cgen_parse_unsigned_integer (CGEN_CPU_DESC cd, 282 const char **strp, 283 int opindex, 284 unsigned long *valuep) 285 { 286 bfd_vma value; 287 enum cgen_parse_operand_result result; 288 const char *errmsg; 289 290 errmsg = (* cd->parse_operand_fn) 291 (cd, CGEN_PARSE_OPERAND_INTEGER, strp, opindex, BFD_RELOC_NONE, 292 &result, &value); 293 /* FIXME: Examine `result'. */ 294 if (!errmsg) 295 *valuep = value; 296 return errmsg; 297 } 298 299 /* Address parser. */ 300 301 const char * 302 cgen_parse_address (CGEN_CPU_DESC cd, 303 const char **strp, 304 int opindex, 305 int opinfo, 306 enum cgen_parse_operand_result *resultp, 307 bfd_vma *valuep) 308 { 309 bfd_vma value; 310 enum cgen_parse_operand_result result_type; 311 const char *errmsg; 312 313 errmsg = (* cd->parse_operand_fn) 314 (cd, CGEN_PARSE_OPERAND_ADDRESS, strp, opindex, opinfo, 315 &result_type, &value); 316 /* FIXME: Examine `result'. */ 317 if (!errmsg) 318 { 319 if (resultp != NULL) 320 *resultp = result_type; 321 *valuep = value; 322 } 323 return errmsg; 324 } 325 326 /* Signed integer validation routine. */ 327 328 const char * 329 cgen_validate_signed_integer (long value, long min, long max) 330 { 331 if (value < min || value > max) 332 { 333 static char buf[100]; 334 335 /* xgettext:c-format */ 336 sprintf (buf, _("operand out of range (%ld not between %ld and %ld)"), 337 value, min, max); 338 return buf; 339 } 340 341 return NULL; 342 } 343 344 /* Unsigned integer validation routine. 345 Supplying `min' here may seem unnecessary, but we also want to handle 346 cases where min != 0 (and max > LONG_MAX). */ 347 348 const char * 349 cgen_validate_unsigned_integer (unsigned long value, 350 unsigned long min, 351 unsigned long max) 352 { 353 if (value < min || value > max) 354 { 355 static char buf[100]; 356 357 /* xgettext:c-format */ 358 sprintf (buf, _("operand out of range (%lu not between %lu and %lu)"), 359 value, min, max); 360 return buf; 361 } 362 363 return NULL; 364 } 365