1 /* tc-pj.c -- Assemble code for Pico Java 2 Copyright 1999, 2000, 2001, 2002, 2003, 2005, 2007 3 Free Software Foundation, Inc. 4 5 This file is part of GAS, the GNU Assembler. 6 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) 10 any later version. 11 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. 16 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 19 the Free Software Foundation, 51 Franklin Street - Fifth Floor, 20 Boston, MA 02110-1301, USA. */ 21 22 /* Contributed by Steve Chamberlain of Transmeta <sac@pobox.com>. */ 23 24 #include "as.h" 25 #include "safe-ctype.h" 26 #include "opcode/pj.h" 27 28 extern const pj_opc_info_t pj_opc_info[512]; 29 30 const char comment_chars[] = "!/"; 31 const char line_separator_chars[] = ";"; 32 const char line_comment_chars[] = "/!#"; 33 34 static int pending_reloc; 35 static struct hash_control *opcode_hash_control; 36 37 static void 38 little (int ignore ATTRIBUTE_UNUSED) 39 { 40 target_big_endian = 0; 41 } 42 43 static void 44 big (int ignore ATTRIBUTE_UNUSED) 45 { 46 target_big_endian = 1; 47 } 48 49 const pseudo_typeS md_pseudo_table[] = 50 { 51 {"ml", little, 0}, 52 {"mb", big, 0}, 53 {0, 0, 0} 54 }; 55 56 const char FLT_CHARS[] = "rRsSfFdDxXpP"; 57 const char EXP_CHARS[] = "eE"; 58 59 void 60 md_operand (expressionS *op) 61 { 62 if (strncmp (input_line_pointer, "%hi16", 5) == 0) 63 { 64 if (pending_reloc) 65 as_bad (_("confusing relocation expressions")); 66 pending_reloc = BFD_RELOC_PJ_CODE_HI16; 67 input_line_pointer += 5; 68 expression (op); 69 } 70 71 if (strncmp (input_line_pointer, "%lo16", 5) == 0) 72 { 73 if (pending_reloc) 74 as_bad (_("confusing relocation expressions")); 75 pending_reloc = BFD_RELOC_PJ_CODE_LO16; 76 input_line_pointer += 5; 77 expression (op); 78 } 79 } 80 81 /* Parse an expression and then restore the input line pointer. */ 82 83 static char * 84 parse_exp_save_ilp (char *s, expressionS *op) 85 { 86 char *save = input_line_pointer; 87 88 input_line_pointer = s; 89 expression (op); 90 s = input_line_pointer; 91 input_line_pointer = save; 92 return s; 93 } 94 95 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a 96 reloc for a cons. We could use the definition there, except that 97 we want to handle magic pending reloc expressions specially. */ 98 99 void 100 pj_cons_fix_new_pj (fragS *frag, int where, int nbytes, expressionS *exp) 101 { 102 static int rv[5][2] = 103 { { 0, 0 }, 104 { BFD_RELOC_8, BFD_RELOC_8 }, 105 { BFD_RELOC_PJ_CODE_DIR16, BFD_RELOC_16 }, 106 { 0, 0 }, 107 { BFD_RELOC_PJ_CODE_DIR32, BFD_RELOC_32 }}; 108 109 fix_new_exp (frag, where, nbytes, exp, 0, 110 pending_reloc ? pending_reloc 111 : rv[nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]); 112 113 pending_reloc = 0; 114 } 115 116 /* Turn a reloc description character from the pj-opc.h table into 117 code which BFD can handle. */ 118 119 static int 120 c_to_r (int x) 121 { 122 switch (x) 123 { 124 case O_R8: 125 return BFD_RELOC_8_PCREL; 126 case O_U8: 127 case O_8: 128 return BFD_RELOC_8; 129 case O_R16: 130 return BFD_RELOC_PJ_CODE_REL16; 131 case O_U16: 132 case O_16: 133 return BFD_RELOC_PJ_CODE_DIR16; 134 case O_R32: 135 return BFD_RELOC_PJ_CODE_REL32; 136 case O_32: 137 return BFD_RELOC_PJ_CODE_DIR32; 138 } 139 abort (); 140 return 0; 141 } 142 143 /* Handler for the ipush fake opcode, 144 turns ipush <foo> into sipush lo16<foo>, sethi hi16<foo>. */ 145 146 static void 147 ipush_code (pj_opc_info_t *opcode ATTRIBUTE_UNUSED, char *str) 148 { 149 char *b = frag_more (6); 150 expressionS arg; 151 152 b[0] = 0x11; 153 b[3] = 0xed; 154 parse_exp_save_ilp (str + 1, &arg); 155 if (pending_reloc) 156 { 157 as_bad (_("can't have relocation for ipush")); 158 pending_reloc = 0; 159 } 160 161 fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2, 162 &arg, 0, BFD_RELOC_PJ_CODE_DIR16); 163 fix_new_exp (frag_now, b - frag_now->fr_literal + 4, 2, 164 &arg, 0, BFD_RELOC_PJ_CODE_HI16); 165 } 166 167 /* Insert names into the opcode table which are really mini macros, 168 not opcodes. The fakeness is indicated with an opcode of -1. */ 169 170 static void 171 fake_opcode (const char *name, 172 void (*func) (struct pj_opc_info_t *, char *)) 173 { 174 pj_opc_info_t * fake = xmalloc (sizeof (pj_opc_info_t)); 175 176 fake->opcode = -1; 177 fake->opcode_next = -1; 178 fake->u.func = func; 179 hash_insert (opcode_hash_control, name, (char *) fake); 180 } 181 182 /* Enter another entry into the opcode hash table so the same opcode 183 can have another name. */ 184 185 static void 186 alias (const char *new, const char *old) 187 { 188 hash_insert (opcode_hash_control, new, 189 (char *) hash_find (opcode_hash_control, old)); 190 } 191 192 /* This function is called once, at assembler startup time. It sets 193 up the hash table with all the opcodes in it, and also initializes 194 some aliases for compatibility with other assemblers. */ 195 196 void 197 md_begin (void) 198 { 199 const pj_opc_info_t *opcode; 200 opcode_hash_control = hash_new (); 201 202 /* Insert names into hash table. */ 203 for (opcode = pj_opc_info; opcode->u.name; opcode++) 204 hash_insert (opcode_hash_control, opcode->u.name, (char *) opcode); 205 206 /* Insert the only fake opcode. */ 207 fake_opcode ("ipush", ipush_code); 208 209 /* Add some aliases for opcode names. */ 210 alias ("ifeq_s", "ifeq"); 211 alias ("ifne_s", "ifne"); 212 alias ("if_icmpge_s", "if_icmpge"); 213 alias ("if_icmpne_s", "if_icmpne"); 214 alias ("if_icmpeq_s", "if_icmpeq"); 215 alias ("if_icmpgt_s", "if_icmpgt"); 216 alias ("goto_s", "goto"); 217 218 bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0); 219 } 220 221 /* This is the guts of the machine-dependent assembler. STR points to 222 a machine dependent instruction. This function is supposed to emit 223 the frags/bytes it assembles to. */ 224 225 void 226 md_assemble (char *str) 227 { 228 char *op_start; 229 char *op_end; 230 231 pj_opc_info_t *opcode; 232 char *output; 233 int idx = 0; 234 char pend; 235 236 int nlen = 0; 237 238 /* Drop leading whitespace. */ 239 while (*str == ' ') 240 str++; 241 242 /* Find the op code end. */ 243 op_start = str; 244 for (op_end = str; 245 *op_end && !is_end_of_line[*op_end & 0xff] && *op_end != ' '; 246 op_end++) 247 nlen++; 248 249 pend = *op_end; 250 *op_end = 0; 251 252 if (nlen == 0) 253 as_bad (_("can't find opcode ")); 254 255 opcode = (pj_opc_info_t *) hash_find (opcode_hash_control, op_start); 256 *op_end = pend; 257 258 if (opcode == NULL) 259 { 260 as_bad (_("unknown opcode %s"), op_start); 261 return; 262 } 263 264 if (opcode->opcode == -1) 265 { 266 /* It's a fake opcode. Dig out the args and pretend that was 267 what we were passed. */ 268 (*opcode->u.func) (opcode, op_end); 269 } 270 else 271 { 272 int an; 273 274 output = frag_more (opcode->len); 275 output[idx++] = opcode->opcode; 276 277 if (opcode->opcode_next != -1) 278 output[idx++] = opcode->opcode_next; 279 280 for (an = 0; opcode->arg[an]; an++) 281 { 282 expressionS arg; 283 284 if (*op_end == ',' && an != 0) 285 op_end++; 286 287 if (*op_end == 0) 288 as_bad ("expected expresssion"); 289 290 op_end = parse_exp_save_ilp (op_end, &arg); 291 292 fix_new_exp (frag_now, 293 output - frag_now->fr_literal + idx, 294 ASIZE (opcode->arg[an]), 295 &arg, 296 PCREL (opcode->arg[an]), 297 pending_reloc ? pending_reloc : c_to_r (opcode->arg[an])); 298 299 idx += ASIZE (opcode->arg[an]); 300 pending_reloc = 0; 301 } 302 303 while (ISSPACE (*op_end)) 304 op_end++; 305 306 if (*op_end != 0) 307 as_warn ("extra stuff on line ignored"); 308 309 } 310 311 if (pending_reloc) 312 as_bad ("Something forgot to clean up\n"); 313 314 } 315 316 char * 317 md_atof (int type, char *litP, int *sizeP) 318 { 319 return ieee_md_atof (type, litP, sizeP, target_big_endian); 320 } 321 322 const char *md_shortopts = ""; 323 324 struct option md_longopts[] = 325 { 326 #define OPTION_LITTLE (OPTION_MD_BASE) 327 #define OPTION_BIG (OPTION_LITTLE + 1) 328 329 {"little", no_argument, NULL, OPTION_LITTLE}, 330 {"big", no_argument, NULL, OPTION_BIG}, 331 {NULL, no_argument, NULL, 0} 332 }; 333 size_t md_longopts_size = sizeof (md_longopts); 334 335 int 336 md_parse_option (int c, char *arg ATTRIBUTE_UNUSED) 337 { 338 switch (c) 339 { 340 case OPTION_LITTLE: 341 little (0); 342 break; 343 case OPTION_BIG: 344 big (0); 345 break; 346 default: 347 return 0; 348 } 349 return 1; 350 } 351 352 void 353 md_show_usage (FILE *stream) 354 { 355 fprintf (stream, _("\ 356 PJ options:\n\ 357 -little generate little endian code\n\ 358 -big generate big endian code\n")); 359 } 360 361 /* Apply a fixup to the object file. */ 362 363 void 364 md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED) 365 { 366 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; 367 long val = *valP; 368 long max, min; 369 int shift; 370 371 max = min = 0; 372 shift = 0; 373 switch (fixP->fx_r_type) 374 { 375 case BFD_RELOC_VTABLE_INHERIT: 376 case BFD_RELOC_VTABLE_ENTRY: 377 fixP->fx_done = 0; 378 return; 379 380 case BFD_RELOC_PJ_CODE_REL16: 381 if (val < -0x8000 || val >= 0x7fff) 382 as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far")); 383 buf[0] |= (val >> 8) & 0xff; 384 buf[1] = val & 0xff; 385 break; 386 387 case BFD_RELOC_PJ_CODE_HI16: 388 *buf++ = val >> 24; 389 *buf++ = val >> 16; 390 fixP->fx_addnumber = val & 0xffff; 391 break; 392 393 case BFD_RELOC_PJ_CODE_DIR16: 394 case BFD_RELOC_PJ_CODE_LO16: 395 *buf++ = val >> 8; 396 *buf++ = val >> 0; 397 398 max = 0xffff; 399 min = -0xffff; 400 break; 401 402 case BFD_RELOC_8: 403 max = 0xff; 404 min = -0xff; 405 *buf++ = val; 406 break; 407 408 case BFD_RELOC_PJ_CODE_DIR32: 409 *buf++ = val >> 24; 410 *buf++ = val >> 16; 411 *buf++ = val >> 8; 412 *buf++ = val >> 0; 413 break; 414 415 case BFD_RELOC_32: 416 if (target_big_endian) 417 { 418 *buf++ = val >> 24; 419 *buf++ = val >> 16; 420 *buf++ = val >> 8; 421 *buf++ = val >> 0; 422 } 423 else 424 { 425 *buf++ = val >> 0; 426 *buf++ = val >> 8; 427 *buf++ = val >> 16; 428 *buf++ = val >> 24; 429 } 430 break; 431 432 case BFD_RELOC_16: 433 if (target_big_endian) 434 { 435 *buf++ = val >> 8; 436 *buf++ = val >> 0; 437 } 438 else 439 { 440 *buf++ = val >> 0; 441 *buf++ = val >> 8; 442 } 443 break; 444 445 default: 446 abort (); 447 } 448 449 if (max != 0 && (val < min || val > max)) 450 as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range")); 451 452 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) 453 fixP->fx_done = 1; 454 } 455 456 /* Put number into target byte order. Always put values in an 457 executable section into big endian order. */ 458 459 void 460 md_number_to_chars (char *ptr, valueT use, int nbytes) 461 { 462 if (target_big_endian || now_seg->flags & SEC_CODE) 463 number_to_chars_bigendian (ptr, use, nbytes); 464 else 465 number_to_chars_littleendian (ptr, use, nbytes); 466 } 467 468 /* Translate internal representation of relocation info to BFD target 469 format. */ 470 471 arelent * 472 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp) 473 { 474 arelent *rel; 475 bfd_reloc_code_real_type r_type; 476 477 rel = xmalloc (sizeof (arelent)); 478 rel->sym_ptr_ptr = xmalloc (sizeof (asymbol *)); 479 *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 480 rel->address = fixp->fx_frag->fr_address + fixp->fx_where; 481 482 r_type = fixp->fx_r_type; 483 rel->addend = fixp->fx_addnumber; 484 rel->howto = bfd_reloc_type_lookup (stdoutput, r_type); 485 486 if (rel->howto == NULL) 487 { 488 as_bad_where (fixp->fx_file, fixp->fx_line, 489 _("Cannot represent relocation type %s"), 490 bfd_get_reloc_code_name (r_type)); 491 /* Set howto to a garbage value so that we can keep going. */ 492 rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32); 493 assert (rel->howto != NULL); 494 } 495 496 return rel; 497 } 498