1 /* tc-vax.c - vax-specific - 2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001, 2002, 3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 4 Free Software Foundation, Inc. 5 6 This file is part of GAS, the GNU Assembler. 7 8 GAS 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 3, or (at your option) 11 any later version. 12 13 GAS 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 19 along with GAS; see the file COPYING. If not, write to the Free 20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 #include "as.h" 24 25 #include "vax-inst.h" 26 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */ 27 #include "subsegs.h" 28 #include "safe-ctype.h" 29 30 #ifdef OBJ_ELF 31 #include "elf/vax.h" 32 #endif 33 34 /* These chars start a comment anywhere in a source file (except inside 35 another comment */ 36 const char comment_chars[] = "#"; 37 38 /* These chars only start a comment at the beginning of a line. */ 39 /* Note that for the VAX the are the same as comment_chars above. */ 40 const char line_comment_chars[] = "#"; 41 42 const char line_separator_chars[] = ";"; 43 44 /* Chars that can be used to separate mant from exp in floating point nums. */ 45 const char EXP_CHARS[] = "eE"; 46 47 /* Chars that mean this number is a floating point constant 48 as in 0f123.456 49 or 0H1.234E-12 (see exp chars above). */ 50 const char FLT_CHARS[] = "dDfFgGhH"; 51 52 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be 53 changed in read.c . Ideally it shouldn't have to know about it at all, 54 but nothing is ideal around here. */ 55 56 /* Hold details of an operand expression. */ 57 static expressionS exp_of_operand[VIT_MAX_OPERANDS]; 58 static segT seg_of_operand[VIT_MAX_OPERANDS]; 59 60 /* A vax instruction after decoding. */ 61 static struct vit v; 62 63 /* Hold details of big operands. */ 64 LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER]; 65 FLONUM_TYPE float_operand[VIT_MAX_OPERANDS]; 66 /* Above is made to point into big_operand_bits by md_begin(). */ 67 68 #ifdef OBJ_ELF 69 #define GLOBAL_OFFSET_TABLE_NAME "_GLOBAL_OFFSET_TABLE_" 70 #define PROCEDURE_LINKAGE_TABLE_NAME "_PROCEDURE_LINKAGE_TABLE_" 71 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_". */ 72 symbolS *PLT_symbol; /* Pre-defined "_PROCEDURE_LINKAGE_TABLE_". */ 73 #endif 74 75 int flag_hash_long_names; /* -+ */ 76 int flag_one; /* -1 */ 77 int flag_show_after_trunc; /* -H */ 78 int flag_no_hash_mixed_case; /* -h NUM */ 79 #ifdef OBJ_ELF 80 int flag_want_pic; /* -k */ 81 #endif 82 83 /* For VAX, relative addresses of "just the right length" are easy. 84 The branch displacement is always the last operand, even in 85 synthetic instructions. 86 For VAX, we encode the relax_substateTs (in e.g. fr_substate) as: 87 88 4 3 2 1 0 bit number 89 ---/ /--+-------+-------+-------+-------+-------+ 90 | what state ? | how long ? | 91 ---/ /--+-------+-------+-------+-------+-------+ 92 93 The "how long" bits are 00=byte, 01=word, 10=long. 94 This is a Un*x convention. 95 Not all lengths are legit for a given value of (what state). 96 The "how long" refers merely to the displacement length. 97 The address usually has some constant bytes in it as well. 98 99 groups for VAX address relaxing. 100 101 1. "foo" pc-relative. 102 length of byte, word, long 103 104 2a. J<cond> where <cond> is a simple flag test. 105 length of byte, word, long. 106 VAX opcodes are: (Hex) 107 bneq/bnequ 12 108 beql/beqlu 13 109 bgtr 14 110 bleq 15 111 bgeq 18 112 blss 19 113 bgtru 1a 114 blequ 1b 115 bvc 1c 116 bvs 1d 117 bgequ/bcc 1e 118 blssu/bcs 1f 119 Always, you complement 0th bit to reverse condition. 120 Always, 1-byte opcode, then 1-byte displacement. 121 122 2b. J<cond> where cond tests a memory bit. 123 length of byte, word, long. 124 Vax opcodes are: (Hex) 125 bbs e0 126 bbc e1 127 bbss e2 128 bbcs e3 129 bbsc e4 130 bbcc e5 131 Always, you complement 0th bit to reverse condition. 132 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement 133 134 2c. J<cond> where cond tests low-order memory bit 135 length of byte,word,long. 136 Vax opcodes are: (Hex) 137 blbs e8 138 blbc e9 139 Always, you complement 0th bit to reverse condition. 140 Always, 1-byte opcode, longword-address, 1-byte displacement. 141 142 3. Jbs/Jbr. 143 length of byte,word,long. 144 Vax opcodes are: (Hex) 145 bsbb 10 146 brb 11 147 These are like (2) but there is no condition to reverse. 148 Always, 1 byte opcode, then displacement/absolute. 149 150 4a. JacbX 151 length of word, long. 152 Vax opcodes are: (Hex) 153 acbw 3d 154 acbf 4f 155 acbd 6f 156 abcb 9d 157 acbl f1 158 acbg 4ffd 159 acbh 6ffd 160 Always, we cannot reverse the sense of the branch; we have a word 161 displacement. 162 The double-byte op-codes don't hurt: we never want to modify the 163 opcode, so we don't care how many bytes are between the opcode and 164 the operand. 165 166 4b. JXobXXX 167 length of long, long, byte. 168 Vax opcodes are: (Hex) 169 aoblss f2 170 aobleq f3 171 sobgeq f4 172 sobgtr f5 173 Always, we cannot reverse the sense of the branch; we have a byte 174 displacement. 175 176 The only time we need to modify the opcode is for class 2 instructions. 177 After relax() we may complement the lowest order bit of such instruction 178 to reverse sense of branch. 179 180 For class 2 instructions, we store context of "where is the opcode literal". 181 We can change an opcode's lowest order bit without breaking anything else. 182 183 We sometimes store context in the operand literal. This way we can figure out 184 after relax() what the original addressing mode was. */ 185 186 /* These displacements are relative to the start address of the 187 displacement. The first letter is Byte, Word. 2nd letter is 188 Forward, Backward. */ 189 #define BF (1+ 127) 190 #define BB (1+-128) 191 #define WF (2+ 32767) 192 #define WB (2+-32768) 193 /* Dont need LF, LB because they always reach. [They are coded as 0.] */ 194 195 #define C(a,b) ENCODE_RELAX(a,b) 196 /* This macro has no side-effects. */ 197 #define ENCODE_RELAX(what,length) (((what) << 2) + (length)) 198 #define RELAX_STATE(s) ((s) >> 2) 199 #define RELAX_LENGTH(s) ((s) & 3) 200 201 const relax_typeS md_relax_table[] = 202 { 203 {1, 1, 0, 0}, /* error sentinel 0,0 */ 204 {1, 1, 0, 0}, /* unused 0,1 */ 205 {1, 1, 0, 0}, /* unused 0,2 */ 206 {1, 1, 0, 0}, /* unused 0,3 */ 207 208 {BF + 1, BB + 1, 2, C (1, 1)},/* B^"foo" 1,0 */ 209 {WF + 1, WB + 1, 3, C (1, 2)},/* W^"foo" 1,1 */ 210 {0, 0, 5, 0}, /* L^"foo" 1,2 */ 211 {1, 1, 0, 0}, /* unused 1,3 */ 212 213 {BF, BB, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */ 214 {WF + 2, WB + 2, 4, C (2, 2)},/* br.+? brw X 2,1 */ 215 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */ 216 {1, 1, 0, 0}, /* unused 2,3 */ 217 218 {BF, BB, 1, C (3, 1)}, /* brb B^foo 3,0 */ 219 {WF, WB, 2, C (3, 2)}, /* brw W^foo 3,1 */ 220 {0, 0, 5, 0}, /* Jmp L^foo 3,2 */ 221 {1, 1, 0, 0}, /* unused 3,3 */ 222 223 {1, 1, 0, 0}, /* unused 4,0 */ 224 {WF, WB, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */ 225 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */ 226 {1, 1, 0, 0}, /* unused 4,3 */ 227 228 {BF, BB, 1, C (5, 1)}, /* Xob___,,foo 5,0 */ 229 {WF + 4, WB + 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */ 230 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */ 231 {1, 1, 0, 0}, /* unused 5,3 */ 232 }; 233 234 #undef C 235 #undef BF 236 #undef BB 237 #undef WF 238 #undef WB 239 240 void float_cons (int); 241 int flonum_gen2vax (char, FLONUM_TYPE *, LITTLENUM_TYPE *); 242 243 const pseudo_typeS md_pseudo_table[] = 244 { 245 {"dfloat", float_cons, 'd'}, 246 {"ffloat", float_cons, 'f'}, 247 {"gfloat", float_cons, 'g'}, 248 {"hfloat", float_cons, 'h'}, 249 {"d_floating", float_cons, 'd'}, 250 {"f_floating", float_cons, 'f'}, 251 {"g_floating", float_cons, 'g'}, 252 {"h_floating", float_cons, 'h'}, 253 {NULL, NULL, 0}, 254 }; 255 256 #define STATE_PC_RELATIVE (1) 257 #define STATE_CONDITIONAL_BRANCH (2) 258 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */ 259 #define STATE_COMPLEX_BRANCH (4) 260 #define STATE_COMPLEX_HOP (5) 261 262 #define STATE_BYTE (0) 263 #define STATE_WORD (1) 264 #define STATE_LONG (2) 265 #define STATE_UNDF (3) /* Symbol undefined in pass1. */ 266 267 #define min(a, b) ((a) < (b) ? (a) : (b)) 268 269 void 270 md_number_to_chars (char con[], valueT value, int nbytes) 271 { 272 number_to_chars_littleendian (con, value, nbytes); 273 } 274 275 /* Fix up some data or instructions after we find out the value of a symbol 276 that they reference. */ 277 278 void /* Knows about order of bytes in address. */ 279 md_apply_fix (fixS *fixP, valueT *valueP, segT seg ATTRIBUTE_UNUSED) 280 { 281 valueT value = * valueP; 282 283 if (((fixP->fx_addsy == NULL && fixP->fx_subsy == NULL) 284 && fixP->fx_r_type != BFD_RELOC_32_PLT_PCREL 285 && fixP->fx_r_type != BFD_RELOC_32_GOT_PCREL) 286 || fixP->fx_r_type == NO_RELOC) 287 number_to_chars_littleendian (fixP->fx_where + fixP->fx_frag->fr_literal, 288 value, fixP->fx_size); 289 290 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) 291 fixP->fx_done = 1; 292 } 293 294 /* Convert a number from VAX byte order (little endian) 295 into host byte order. 296 con is the buffer to convert, 297 nbytes is the length of the given buffer. */ 298 static long 299 md_chars_to_number (unsigned char con[], int nbytes) 300 { 301 long retval; 302 303 for (retval = 0, con += nbytes - 1; nbytes--; con--) 304 { 305 retval <<= BITS_PER_CHAR; 306 retval |= *con; 307 } 308 return retval; 309 } 310 311 /* Copy a bignum from in to out. 312 If the output is shorter than the input, copy lower-order 313 littlenums. Return 0 or the number of significant littlenums 314 dropped. Assumes littlenum arrays are densely packed: no unused 315 chars between the littlenums. Uses memcpy() to move littlenums, and 316 wants to know length (in chars) of the input bignum. */ 317 318 static int 319 bignum_copy (LITTLENUM_TYPE *in, 320 int in_length, /* in sizeof(littlenum)s */ 321 LITTLENUM_TYPE *out, 322 int out_length /* in sizeof(littlenum)s */) 323 { 324 int significant_littlenums_dropped; 325 326 if (out_length < in_length) 327 { 328 LITTLENUM_TYPE *p; /* -> most significant (non-zero) input 329 littlenum. */ 330 331 memcpy ((void *) out, (void *) in, 332 (unsigned int) out_length << LITTLENUM_SHIFT); 333 for (p = in + in_length - 1; p >= in; --p) 334 { 335 if (*p) 336 break; 337 } 338 significant_littlenums_dropped = p - in - in_length + 1; 339 340 if (significant_littlenums_dropped < 0) 341 significant_littlenums_dropped = 0; 342 } 343 else 344 { 345 memcpy ((char *) out, (char *) in, 346 (unsigned int) in_length << LITTLENUM_SHIFT); 347 348 if (out_length > in_length) 349 memset ((char *) (out + in_length), '\0', 350 (unsigned int) (out_length - in_length) << LITTLENUM_SHIFT); 351 352 significant_littlenums_dropped = 0; 353 } 354 355 return significant_littlenums_dropped; 356 } 357 358 /* md_estimate_size_before_relax(), called just before relax(). 359 Any symbol that is now undefined will not become defined. 360 Return the correct fr_subtype in the frag and the growth beyond 361 fr_fix. */ 362 int 363 md_estimate_size_before_relax (fragS *fragP, segT segment) 364 { 365 if (RELAX_LENGTH (fragP->fr_subtype) == STATE_UNDF) 366 { 367 if (S_GET_SEGMENT (fragP->fr_symbol) != segment 368 #ifdef OBJ_ELF 369 || S_IS_WEAK (fragP->fr_symbol) 370 || S_IS_EXTERNAL (fragP->fr_symbol) 371 #endif 372 ) 373 { 374 /* Non-relaxable cases. */ 375 int reloc_type = NO_RELOC; 376 char *p; 377 int old_fr_fix; 378 379 old_fr_fix = fragP->fr_fix; 380 p = fragP->fr_literal + old_fr_fix; 381 #ifdef OBJ_ELF 382 /* If this is to an undefined symbol, then if it's an indirect 383 reference indicate that is can mutated into a GLOB_DAT or 384 JUMP_SLOT by the loader. We restrict ourselves to no offset 385 due to a limitation in the NetBSD linker. */ 386 387 if (GOT_symbol == NULL) 388 GOT_symbol = symbol_find (GLOBAL_OFFSET_TABLE_NAME); 389 if (PLT_symbol == NULL) 390 PLT_symbol = symbol_find (PROCEDURE_LINKAGE_TABLE_NAME); 391 if ((GOT_symbol == NULL || fragP->fr_symbol != GOT_symbol) 392 && (PLT_symbol == NULL || fragP->fr_symbol != PLT_symbol) 393 && fragP->fr_symbol != NULL 394 && flag_want_pic 395 #ifdef OBJ_ELF 396 && ELF_ST_VISIBILITY (S_GET_OTHER (fragP->fr_symbol)) != STV_HIDDEN 397 #endif 398 && (!S_IS_DEFINED (fragP->fr_symbol) 399 || S_IS_WEAK (fragP->fr_symbol) 400 || S_IS_EXTERNAL (fragP->fr_symbol))) 401 { 402 /* Indirect references cannot go through the GOT or PLT, 403 let's hope they'll become local in the final link. */ 404 if ((ELF_ST_VISIBILITY (S_GET_OTHER (fragP->fr_symbol)) 405 != STV_DEFAULT) 406 || (p[0] & 0x10)) 407 reloc_type = BFD_RELOC_32_PCREL; 408 else if (((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLS 409 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLG 410 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JSB 411 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JMP 412 || S_IS_FUNCTION (fragP->fr_symbol)) 413 reloc_type = BFD_RELOC_32_PLT_PCREL; 414 else 415 reloc_type = BFD_RELOC_32_GOT_PCREL; 416 } 417 #endif 418 switch (RELAX_STATE (fragP->fr_subtype)) 419 { 420 case STATE_PC_RELATIVE: 421 p[0] |= VAX_PC_RELATIVE_MODE; /* Preserve @ bit. */ 422 fragP->fr_fix += 1 + 4; 423 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 424 fragP->fr_offset, 1, reloc_type); 425 break; 426 427 case STATE_CONDITIONAL_BRANCH: 428 *fragP->fr_opcode ^= 1; /* Reverse sense of branch. */ 429 p[0] = 6; 430 p[1] = VAX_JMP; 431 p[2] = VAX_PC_RELATIVE_MODE; /* ...(PC) */ 432 fragP->fr_fix += 1 + 1 + 1 + 4; 433 fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol, 434 fragP->fr_offset, 1, NO_RELOC); 435 break; 436 437 case STATE_COMPLEX_BRANCH: 438 p[0] = 2; 439 p[1] = 0; 440 p[2] = VAX_BRB; 441 p[3] = 6; 442 p[4] = VAX_JMP; 443 p[5] = VAX_PC_RELATIVE_MODE; /* ...(pc) */ 444 fragP->fr_fix += 2 + 2 + 1 + 1 + 4; 445 fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol, 446 fragP->fr_offset, 1, NO_RELOC); 447 break; 448 449 case STATE_COMPLEX_HOP: 450 p[0] = 2; 451 p[1] = VAX_BRB; 452 p[2] = 6; 453 p[3] = VAX_JMP; 454 p[4] = VAX_PC_RELATIVE_MODE; /* ...(pc) */ 455 fragP->fr_fix += 1 + 2 + 1 + 1 + 4; 456 fix_new (fragP, old_fr_fix + 5, 4, fragP->fr_symbol, 457 fragP->fr_offset, 1, NO_RELOC); 458 break; 459 460 case STATE_ALWAYS_BRANCH: 461 *fragP->fr_opcode += VAX_WIDEN_LONG; 462 p[0] = VAX_PC_RELATIVE_MODE; /* ...(PC) */ 463 fragP->fr_fix += 1 + 4; 464 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 465 fragP->fr_offset, 1, NO_RELOC); 466 break; 467 468 default: 469 abort (); 470 } 471 frag_wane (fragP); 472 473 /* Return the growth in the fixed part of the frag. */ 474 return fragP->fr_fix - old_fr_fix; 475 } 476 477 /* Relaxable cases. Set up the initial guess for the variable 478 part of the frag. */ 479 switch (RELAX_STATE (fragP->fr_subtype)) 480 { 481 case STATE_PC_RELATIVE: 482 fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE); 483 break; 484 case STATE_CONDITIONAL_BRANCH: 485 fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE); 486 break; 487 case STATE_COMPLEX_BRANCH: 488 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD); 489 break; 490 case STATE_COMPLEX_HOP: 491 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE); 492 break; 493 case STATE_ALWAYS_BRANCH: 494 fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE); 495 break; 496 } 497 } 498 499 if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0])) 500 abort (); 501 502 /* Return the size of the variable part of the frag. */ 503 return md_relax_table[fragP->fr_subtype].rlx_length; 504 } 505 506 /* Called after relax() is finished. 507 In: Address of frag. 508 fr_type == rs_machine_dependent. 509 fr_subtype is what the address relaxed to. 510 511 Out: Any fixSs and constants are set up. 512 Caller will turn frag into a ".space 0". */ 513 void 514 md_convert_frag (bfd *headers ATTRIBUTE_UNUSED, 515 segT seg ATTRIBUTE_UNUSED, 516 fragS *fragP) 517 { 518 char *addressP; /* -> _var to change. */ 519 char *opcodeP; /* -> opcode char(s) to change. */ 520 short int extension = 0; /* Size of relaxed address. */ 521 /* Added to fr_fix: incl. ALL var chars. */ 522 symbolS *symbolP; 523 long where; 524 525 know (fragP->fr_type == rs_machine_dependent); 526 where = fragP->fr_fix; 527 addressP = fragP->fr_literal + where; 528 opcodeP = fragP->fr_opcode; 529 symbolP = fragP->fr_symbol; 530 know (symbolP); 531 532 switch (fragP->fr_subtype) 533 { 534 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE): 535 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */ 536 addressP[0] |= 0xAF; /* Byte displacement. */ 537 fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol, 538 fragP->fr_offset, 1, NO_RELOC); 539 extension = 2; 540 break; 541 542 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD): 543 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */ 544 addressP[0] |= 0xCF; /* Word displacement. */ 545 fix_new (fragP, fragP->fr_fix + 1, 2, fragP->fr_symbol, 546 fragP->fr_offset, 1, NO_RELOC); 547 extension = 3; 548 break; 549 550 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG): 551 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */ 552 addressP[0] |= 0xEF; /* Long word displacement. */ 553 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol, 554 fragP->fr_offset, 1, NO_RELOC); 555 extension = 5; 556 break; 557 558 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE): 559 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol, 560 fragP->fr_offset, 1, NO_RELOC); 561 extension = 1; 562 break; 563 564 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD): 565 opcodeP[0] ^= 1; /* Reverse sense of test. */ 566 addressP[0] = 3; 567 addressP[1] = VAX_BRW; 568 fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol, 569 fragP->fr_offset, 1, NO_RELOC); 570 extension = 4; 571 break; 572 573 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG): 574 opcodeP[0] ^= 1; /* Reverse sense of test. */ 575 addressP[0] = 6; 576 addressP[1] = VAX_JMP; 577 addressP[2] = VAX_PC_RELATIVE_MODE; 578 fix_new (fragP, fragP->fr_fix + 3, 4, fragP->fr_symbol, 579 fragP->fr_offset, 1, NO_RELOC); 580 extension = 7; 581 break; 582 583 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE): 584 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol, 585 fragP->fr_offset, 1, NO_RELOC); 586 extension = 1; 587 break; 588 589 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_WORD): 590 opcodeP[0] += VAX_WIDEN_WORD; /* brb -> brw, bsbb -> bsbw */ 591 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset, 592 1, NO_RELOC); 593 extension = 2; 594 break; 595 596 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_LONG): 597 opcodeP[0] += VAX_WIDEN_LONG; /* brb -> jmp, bsbb -> jsb */ 598 addressP[0] = VAX_PC_RELATIVE_MODE; 599 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol, 600 fragP->fr_offset, 1, NO_RELOC); 601 extension = 5; 602 break; 603 604 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD): 605 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, 606 fragP->fr_offset, 1, NO_RELOC); 607 extension = 2; 608 break; 609 610 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_LONG): 611 addressP[0] = 2; 612 addressP[1] = 0; 613 addressP[2] = VAX_BRB; 614 addressP[3] = 6; 615 addressP[4] = VAX_JMP; 616 addressP[5] = VAX_PC_RELATIVE_MODE; 617 fix_new (fragP, fragP->fr_fix + 6, 4, fragP->fr_symbol, 618 fragP->fr_offset, 1, NO_RELOC); 619 extension = 10; 620 break; 621 622 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE): 623 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol, 624 fragP->fr_offset, 1, NO_RELOC); 625 extension = 1; 626 break; 627 628 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_WORD): 629 addressP[0] = 2; 630 addressP[1] = VAX_BRB; 631 addressP[2] = 3; 632 addressP[3] = VAX_BRW; 633 fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol, 634 fragP->fr_offset, 1, NO_RELOC); 635 extension = 6; 636 break; 637 638 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_LONG): 639 addressP[0] = 2; 640 addressP[1] = VAX_BRB; 641 addressP[2] = 6; 642 addressP[3] = VAX_JMP; 643 addressP[4] = VAX_PC_RELATIVE_MODE; 644 fix_new (fragP, fragP->fr_fix + 5, 4, fragP->fr_symbol, 645 fragP->fr_offset, 1, NO_RELOC); 646 extension = 9; 647 break; 648 649 default: 650 BAD_CASE (fragP->fr_subtype); 651 break; 652 } 653 fragP->fr_fix += extension; 654 } 655 656 /* Translate internal format of relocation info into target format. 657 658 On vax: first 4 bytes are normal unsigned long, next three bytes 659 are symbolnum, least sig. byte first. Last byte is broken up with 660 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and 661 bit 0 as pcrel. */ 662 #ifdef comment 663 void 664 md_ri_to_chars (char *the_bytes, struct reloc_info_generic ri) 665 { 666 /* This is easy. */ 667 md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address)); 668 /* Now the fun stuff. */ 669 the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff; 670 the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff; 671 the_bytes[4] = ri.r_symbolnum & 0x0ff; 672 the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06) 673 | ((ri.r_pcrel << 0) & 0x01)) & 0x0F; 674 } 675 676 #endif /* comment */ 677 678 /* BUGS, GRIPES, APOLOGIA, etc. 679 680 The opcode table 'votstrs' needs to be sorted on opcode frequency. 681 That is, AFTER we hash it with hash_...(), we want most-used opcodes 682 to come out of the hash table faster. 683 684 I am sorry to inflict yet another VAX assembler on the world, but 685 RMS says we must do everything from scratch, to prevent pin-heads 686 restricting this software. 687 688 This is a vaguely modular set of routines in C to parse VAX 689 assembly code using DEC mnemonics. It is NOT un*x specific. 690 691 The idea here is that the assembler has taken care of all: 692 labels 693 macros 694 listing 695 pseudo-ops 696 line continuation 697 comments 698 condensing any whitespace down to exactly one space 699 and all we have to do is parse 1 line into a vax instruction 700 partially formed. We will accept a line, and deliver: 701 an error message (hopefully empty) 702 a skeleton VAX instruction (tree structure) 703 textual pointers to all the operand expressions 704 a warning message that notes a silly operand (hopefully empty) 705 706 E D I T H I S T O R Y 707 708 17may86 Dean Elsner. Bug if line ends immediately after opcode. 709 30apr86 Dean Elsner. New vip_op() uses arg block so change call. 710 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults(). 711 2jan86 Dean Elsner. Invent synthetic opcodes. 712 Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC, 713 which means this is not a real opcode, it is like a macro; it will 714 be relax()ed into 1 or more instructions. 715 Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised 716 like a regular branch instruction. Option added to vip_begin(): 717 exclude synthetic opcodes. Invent synthetic_votstrs[]. 718 31dec85 Dean Elsner. Invent vit_opcode_nbytes. 719 Also make vit_opcode into a char[]. We now have n-byte vax opcodes, 720 so caller's don't have to know the difference between a 1-byte & a 721 2-byte op-code. Still need vax_opcodeT concept, so we know how 722 big an object must be to hold an op.code. 723 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h" 724 because vax opcodes may be 16 bits. Our crufty C compiler was 725 happily initialising 8-bit vot_codes with 16-bit numbers! 726 (Wouldn't the 'phone company like to compress data so easily!) 727 29dec85 Dean Elsner. New static table vax_operand_width_size[]. 728 Invented so we know hw many bytes a "I^#42" needs in its immediate 729 operand. Revised struct vop in "vax-inst.h": explicitly include 730 byte length of each operand, and it's letter-code datum type. 731 17nov85 Dean Elsner. Name Change. 732 Due to ar(1) truncating names, we learned the hard way that 733 "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off 734 the archived object name. SO... we shortened the name of this 735 source file, and changed the makefile. */ 736 737 /* Handle of the OPCODE hash table. */ 738 static struct hash_control *op_hash; 739 740 /* In: 1 character, from "bdfghloqpw" being the data-type of an operand 741 of a vax instruction. 742 743 Out: the length of an operand of that type, in bytes. 744 Special branch operands types "-?!" have length 0. */ 745 746 static const short int vax_operand_width_size[256] = 747 { 748 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 750 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 751 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 752 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */ 753 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */ 754 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */ 755 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */ 756 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 757 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 758 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 759 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 760 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 761 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 762 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 763 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 764 }; 765 766 /* This perversion encodes all the vax opcodes as a bunch of strings. 767 RMS says we should build our hash-table at run-time. Hmm. 768 Please would someone arrange these in decreasing frequency of opcode? 769 Because of the way hash_...() works, the most frequently used opcode 770 should be textually first and so on. 771 772 Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' . 773 So change 'vax.opcodes', then re-generate this table. */ 774 775 #include "opcode/vax.h" 776 777 /* This is a table of optional op-codes. All of them represent 778 'synthetic' instructions that seem popular. 779 780 Here we make some pseudo op-codes. Every code has a bit set to say 781 it is synthetic. This lets you catch them if you want to 782 ban these opcodes. They are mnemonics for "elastic" instructions 783 that are supposed to assemble into the fewest bytes needed to do a 784 branch, or to do a conditional branch, or whatever. 785 786 The opcode is in the usual place [low-order n*8 bits]. This means 787 that if you mask off the bucky bits, the usual rules apply about 788 how long the opcode is. 789 790 All VAX branch displacements come at the end of the instruction. 791 For simple branches (1-byte opcode + 1-byte displacement) the last 792 operand is coded 'b?' where the "data type" '?' is a clue that we 793 may reverse the sense of the branch (complement lowest order bit) 794 and branch around a jump. This is by far the most common case. 795 That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is 796 a 0-byte op-code followed by 2 or more bytes of operand address. 797 798 If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual 799 case. 800 801 For JBSB & JBR the treatment is the similar, except (1) we have a 'bw' 802 option before (2) we can directly JSB/JMP because there is no condition. 803 These operands have 'b-' as their access/data type. 804 805 That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these 806 cases, we do the same idea. JACBxxx are all marked with a 'b!' 807 JAOBxxx & JSOBxxx are marked with a 'b:'. */ 808 #if (VIT_OPCODE_SYNTHETIC != 0x80000000) 809 #error "You have just broken the encoding below, which assumes the sign bit means 'I am an imaginary instruction'." 810 #endif 811 812 #if (VIT_OPCODE_SPECIAL != 0x40000000) 813 #error "You have just broken the encoding below, which assumes the 0x40 M bit means 'I am not to be "optimised" the way normal branches are'." 814 #endif 815 816 static const struct vot 817 synthetic_votstrs[] = 818 { 819 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */ 820 /* jsb used already */ 821 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */ 822 {"jr", {"b-", 0xC0000011}}, /* consistent */ 823 {"jneq", {"b?", 0x80000012}}, 824 {"jnequ", {"b?", 0x80000012}}, 825 {"jeql", {"b?", 0x80000013}}, 826 {"jeqlu", {"b?", 0x80000013}}, 827 {"jgtr", {"b?", 0x80000014}}, 828 {"jleq", {"b?", 0x80000015}}, 829 /* un-used opcodes here */ 830 {"jgeq", {"b?", 0x80000018}}, 831 {"jlss", {"b?", 0x80000019}}, 832 {"jgtru", {"b?", 0x8000001a}}, 833 {"jlequ", {"b?", 0x8000001b}}, 834 {"jvc", {"b?", 0x8000001c}}, 835 {"jvs", {"b?", 0x8000001d}}, 836 {"jgequ", {"b?", 0x8000001e}}, 837 {"jcc", {"b?", 0x8000001e}}, 838 {"jlssu", {"b?", 0x8000001f}}, 839 {"jcs", {"b?", 0x8000001f}}, 840 841 {"jacbw", {"rwrwmwb!", 0xC000003d}}, 842 {"jacbf", {"rfrfmfb!", 0xC000004f}}, 843 {"jacbd", {"rdrdmdb!", 0xC000006f}}, 844 {"jacbb", {"rbrbmbb!", 0xC000009d}}, 845 {"jacbl", {"rlrlmlb!", 0xC00000f1}}, 846 {"jacbg", {"rgrgmgb!", 0xC0004ffd}}, 847 {"jacbh", {"rhrhmhb!", 0xC0006ffd}}, 848 849 {"jbs", {"rlvbb?", 0x800000e0}}, 850 {"jbc", {"rlvbb?", 0x800000e1}}, 851 {"jbss", {"rlvbb?", 0x800000e2}}, 852 {"jbcs", {"rlvbb?", 0x800000e3}}, 853 {"jbsc", {"rlvbb?", 0x800000e4}}, 854 {"jbcc", {"rlvbb?", 0x800000e5}}, 855 {"jbssi", {"rlvbb?", 0x800000e6}}, 856 {"jbcci", {"rlvbb?", 0x800000e7}}, 857 {"jlbs", {"rlb?", 0x800000e8}}, 858 {"jlbc", {"rlb?", 0x800000e9}}, 859 860 {"jaoblss", {"rlmlb:", 0xC00000f2}}, 861 {"jaobleq", {"rlmlb:", 0xC00000f3}}, 862 {"jsobgeq", {"mlb:", 0xC00000f4}}, 863 {"jsobgtr", {"mlb:", 0xC00000f5}}, 864 865 /* CASEx has no branch addresses in our conception of it. */ 866 /* You should use ".word ..." statements after the "case ...". */ 867 868 {"", {"", 0}} /* Empty is end sentinel. */ 869 }; 870 871 /* Because this module is useful for both VMS and UN*X style assemblers 872 and because of the variety of UN*X assemblers we must recognise 873 the different conventions for assembler operand notation. For example 874 VMS says "#42" for immediate mode, while most UN*X say "$42". 875 We permit arbitrary sets of (single) characters to represent the 876 3 concepts that DEC writes '#', '@', '^'. */ 877 878 /* Character tests. */ 879 #define VIP_IMMEDIATE 01 /* Character is like DEC # */ 880 #define VIP_INDIRECT 02 /* Char is like DEC @ */ 881 #define VIP_DISPLEN 04 /* Char is like DEC ^ */ 882 883 #define IMMEDIATEP(c) (vip_metacharacters [(c) & 0xff] & VIP_IMMEDIATE) 884 #define INDIRECTP(c) (vip_metacharacters [(c) & 0xff] & VIP_INDIRECT) 885 #define DISPLENP(c) (vip_metacharacters [(c) & 0xff] & VIP_DISPLEN) 886 887 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we 888 are ever called. */ 889 890 #if defined(CONST_TABLE) 891 #define _ 0, 892 #define I VIP_IMMEDIATE, 893 #define S VIP_INDIRECT, 894 #define D VIP_DISPLEN, 895 static const char 896 vip_metacharacters[256] = 897 { 898 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/ 899 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */ 900 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _ /* sp ! " # $ % & ' ( ) * + , - . / */ 901 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/ 902 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*@ A B C D E F G H I J K L M N O*/ 903 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*P Q R S T U V W X Y Z [ \ ] ^ _*/ 904 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*` a b c d e f g h i j k l m n o*/ 905 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*p q r s t u v w x y z { | } ~ ^?*/ 906 907 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 908 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 909 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 910 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 911 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 912 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 913 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 914 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 915 }; 916 #undef _ 917 #undef I 918 #undef S 919 #undef D 920 921 #else 922 923 static char vip_metacharacters[256]; 924 925 static void 926 vip_op_1 (int bit, const char *syms) 927 { 928 unsigned char t; 929 930 while ((t = *syms++) != 0) 931 vip_metacharacters[t] |= bit; 932 } 933 934 /* Can be called any time. More arguments may appear in future. */ 935 static void 936 vip_op_defaults (const char *immediate, const char *indirect, const char *displen) 937 { 938 vip_op_1 (VIP_IMMEDIATE, immediate); 939 vip_op_1 (VIP_INDIRECT, indirect); 940 vip_op_1 (VIP_DISPLEN, displen); 941 } 942 943 #endif 944 945 /* Call me once before you decode any lines. 946 I decode votstrs into a hash table at op_hash (which I create). 947 I return an error text or null. 948 If you want, I will include the 'synthetic' jXXX instructions in the 949 instruction table. 950 You must nominate metacharacters for eg DEC's "#", "@", "^". */ 951 952 static const char * 953 vip_begin (int synthetic_too, /* 1 means include jXXX op-codes. */ 954 const char *immediate, 955 const char *indirect, 956 const char *displen) 957 { 958 const struct vot *vP; /* scan votstrs */ 959 const char *retval = 0; /* error text */ 960 961 op_hash = hash_new (); 962 963 for (vP = votstrs; *vP->vot_name && !retval; vP++) 964 retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail); 965 966 if (synthetic_too) 967 for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++) 968 retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail); 969 970 #ifndef CONST_TABLE 971 vip_op_defaults (immediate, indirect, displen); 972 #endif 973 974 return retval; 975 } 976 977 /* Take 3 char.s, the last of which may be `\0` (non-existent) 978 and return the VAX register number that they represent. 979 980 Return -1 if they don't form a register name. Good names return 981 a number from 0:15 inclusive. 982 983 Case is not important in a name. 984 985 Register names understood are: 986 987 R0 988 R1 989 R2 990 R3 991 R4 992 R5 993 R6 994 R7 995 R8 996 R9 997 R10 998 R11 999 R12 AP 1000 R13 FP 1001 R14 SP 1002 R15 PC */ 1003 1004 #define AP 12 1005 #define FP 13 1006 #define SP 14 1007 #define PC 15 1008 1009 /* Returns the register number of something like '%r15' or 'ap', supplied 1010 in four single chars. Returns -1 if the register isn't recognized, 1011 0..15 otherwise. */ 1012 static int 1013 vax_reg_parse (char c1, char c2, char c3, char c4) 1014 { 1015 int retval = -1; 1016 1017 #ifdef OBJ_ELF 1018 if (c1 != '%') /* Register prefixes are mandatory for ELF. */ 1019 return retval; 1020 c1 = c2; 1021 c2 = c3; 1022 c3 = c4; 1023 #endif 1024 #ifdef OBJ_VMS 1025 if (c4 != 0) /* Register prefixes are not allowed under VMS. */ 1026 return retval; 1027 #endif 1028 #ifdef OBJ_AOUT 1029 if (c1 == '%') /* Register prefixes are optional under a.out. */ 1030 { 1031 c1 = c2; 1032 c2 = c3; 1033 c3 = c4; 1034 } 1035 else if (c3 && c4) /* Can't be 4 characters long. */ 1036 return retval; 1037 #endif 1038 1039 c1 = TOLOWER (c1); 1040 c2 = TOLOWER (c2); 1041 if (ISDIGIT (c2) && c1 == 'r') 1042 { 1043 retval = c2 - '0'; 1044 if (ISDIGIT (c3)) 1045 { 1046 retval = retval * 10 + c3 - '0'; 1047 retval = (retval > 15) ? -1 : retval; 1048 /* clamp the register value to 1 hex digit */ 1049 } 1050 else if (c3) 1051 retval = -1; /* c3 must be '\0' or a digit. */ 1052 } 1053 else if (c3) /* There are no three letter regs. */ 1054 retval = -1; 1055 else if (c2 == 'p') 1056 { 1057 switch (c1) 1058 { 1059 case 's': 1060 retval = SP; 1061 break; 1062 case 'f': 1063 retval = FP; 1064 break; 1065 case 'a': 1066 retval = AP; 1067 break; 1068 default: 1069 retval = -1; 1070 } 1071 } 1072 else if (c1 == 'p' && c2 == 'c') 1073 retval = PC; 1074 else 1075 retval = -1; 1076 return retval; 1077 } 1078 1079 #ifdef OBJ_AOUT 1080 #ifndef BFD_ASSEMBLER 1081 void 1082 tc_aout_fix_to_chars (where, fixP, segment_address_in_file) 1083 char *where; 1084 fixS *fixP; 1085 relax_addressT segment_address_in_file; 1086 { 1087 /* 1088 * In: length of relocation (or of address) in chars: 1, 2 or 4. 1089 * Out: GNU LD relocation length code: 0, 1, or 2. 1090 */ 1091 1092 static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2}; 1093 int r_symbolnum; 1094 int r_flags; 1095 1096 know (fixP->fx_addsy != NULL); 1097 1098 md_number_to_chars (where, 1099 fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file, 1100 4); 1101 1102 r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy) 1103 ? S_GET_TYPE (fixP->fx_addsy) 1104 : fixP->fx_addsy->sy_number); 1105 r_flags = (fixP->fx_pcrel ? 1 : 0) 1106 | (!S_IS_DEFINED (fixP->fx_addsy) ? 8 : 0) /* extern */ 1107 | ((nbytes_r_length[fixP->fx_size] & 3) << 1); 1108 1109 #if 0 1110 r_flags |= ((!S_IS_DEFINED(fixP->fx_addsy) 1111 && fixP->fx_pcrel 1112 && fixP->fx_addsy != GOT_symbol 1113 && fixP->fx_addsy != PLT_symbol 1114 && flags_want_pic) ? 0x10 : 0); 1115 #endif 1116 1117 switch (fixP->fx_r_type) { 1118 case NO_RELOC: 1119 break; 1120 case NO_RELOC2: 1121 if (r_flags & 8) 1122 r_flags |= 0x80; /* setting the copy bit */ 1123 /* says we can convert */ 1124 /* to gotslot if needed */ 1125 break; 1126 case RELOC_32: 1127 if (flag_want_pic && S_IS_EXTERNAL(fixP->fx_addsy)) { 1128 r_symbolnum = fixP->fx_addsy->sy_number; 1129 r_flags |= 8; /* set extern bit */ 1130 } 1131 break; 1132 case RELOC_JMP_SLOT: 1133 if (flag_want_pic) { 1134 r_flags |= 0x20; /* set jmptable */ 1135 r_flags &= ~0x08; /* clear extern bit */ 1136 } 1137 break; 1138 case RELOC_JMP_TBL: 1139 if (flag_want_pic) { 1140 r_flags |= 0x20; /* set jmptable */ 1141 r_flags |= 0x08; /* set extern bit */ 1142 } 1143 break; 1144 case RELOC_GLOB_DAT: 1145 if (flag_want_pic) { 1146 r_flags |= 0x10; /* set baserel bit */ 1147 r_symbolnum = fixP->fx_addsy->sy_number; 1148 if (S_IS_EXTERNAL(fixP->fx_addsy)) 1149 r_flags |= 8; /* set extern bit */ 1150 } 1151 break; 1152 } 1153 1154 where[4] = (r_symbolnum >> 0) & 0xff; 1155 where[5] = (r_symbolnum >> 8) & 0xff; 1156 where[6] = (r_symbolnum >> 16) & 0xff; 1157 where[7] = r_flags; 1158 } 1159 #endif /* !BFD_ASSEMBLER */ 1160 #endif /* OBJ_AOUT */ 1161 1162 /* 1163 * BUGS, GRIPES, APOLOGIA, etc. 1164 * 1165 * The opcode table 'votstrs' needs to be sorted on opcode frequency. 1166 * That is, AFTER we hash it with hash_...(), we want most-used opcodes 1167 * to come out of the hash table faster. 1168 * 1169 * I am sorry to inflict yet another VAX assembler on the world, but 1170 * RMS says we must do everything from scratch, to prevent pin-heads 1171 * restricting this software. 1172 */ 1173 1174 /* 1175 * This is a vaguely modular set of routines in C to parse VAX 1176 * assembly code using DEC mnemonics. It is NOT un*x specific. 1177 * 1178 * The idea here is that the assembler has taken care of all: 1179 * labels 1180 * macros 1181 * listing 1182 * pseudo-ops 1183 * line continuation 1184 * comments 1185 * condensing any whitespace down to exactly one space 1186 * and all we have to do is parse 1 line into a vax instruction 1187 * partially formed. We will accept a line, and deliver: 1188 * an error message (hopefully empty) 1189 * a skeleton VAX instruction (tree structure) 1190 * textual pointers to all the operand expressions 1191 * a warning message that notes a silly operand (hopefully empty) 1192 */ 1193 1194 /* 1195 * E D I T H I S T O R Y 1196 * 1197 * 17may86 Dean Elsner. Bug if line ends immediately after opcode. 1198 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call. 1199 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults(). 1200 * 2jan86 Dean Elsner. Invent synthetic opcodes. 1201 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC, 1202 * which means this is not a real opcode, it is like a macro; it will 1203 * be relax()ed into 1 or more instructions. 1204 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised 1205 * like a regular branch instruction. Option added to vip_begin(): 1206 * exclude synthetic opcodes. Invent synthetic_votstrs[]. 1207 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes. 1208 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes, 1209 * so caller's don't have to know the difference between a 1-byte & a 1210 * 2-byte op-code. Still need vax_opcodeT concept, so we know how 1211 * big an object must be to hold an op.code. 1212 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h" 1213 * because vax opcodes may be 16 bits. Our crufty C compiler was 1214 * happily initialising 8-bit vot_codes with 16-bit numbers! 1215 * (Wouldn't the 'phone company like to compress data so easily!) 1216 * 29dec85 Dean Elsner. New static table vax_operand_width_size[]. 1217 * Invented so we know hw many bytes a "I^#42" needs in its immediate 1218 * operand. Revised struct vop in "vax-inst.h": explicitly include 1219 * byte length of each operand, and it's letter-code datum type. 1220 * 17nov85 Dean Elsner. Name Change. 1221 * Due to ar(1) truncating names, we learned the hard way that 1222 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off 1223 * the archived object name. SO... we shortened the name of this 1224 * source file, and changed the makefile. 1225 */ 1226 1227 /* Parse a vax operand in DEC assembler notation. 1228 For speed, expect a string of whitespace to be reduced to a single ' '. 1229 This is the case for GNU AS, and is easy for other DEC-compatible 1230 assemblers. 1231 1232 Knowledge about DEC VAX assembler operand notation lives here. 1233 This doesn't even know what a register name is, except it believes 1234 all register names are 2 or 3 characters, and lets vax_reg_parse() say 1235 what number each name represents. 1236 It does, however, know that PC, SP etc are special registers so it can 1237 detect addressing modes that are silly for those registers. 1238 1239 Where possible, it delivers 1 fatal or 1 warning message if the operand 1240 is suspect. Exactly what we test for is still evolving. 1241 1242 --- 1243 Arg block. 1244 1245 There were a number of 'mismatched argument type' bugs to vip_op. 1246 The most general solution is to typedef each (of many) arguments. 1247 We used instead a typedef'd argument block. This is less modular 1248 than using separate return pointers for each result, but runs faster 1249 on most engines, and seems to keep programmers happy. It will have 1250 to be done properly if we ever want to use vip_op as a general-purpose 1251 module (it was designed to be). 1252 1253 G^ 1254 1255 Doesn't support DEC "G^" format operands. These always take 5 bytes 1256 to express, and code as modes 8F or 9F. Reason: "G^" deprives you of 1257 optimising to (say) a "B^" if you are lucky in the way you link. 1258 When someone builds a linker smart enough to convert "G^" to "B^", "W^" 1259 whenever possible, then we should implement it. 1260 If there is some other use for "G^", feel free to code it in! 1261 1262 speed 1263 1264 If I nested if()s more, I could avoid testing (*err) which would save 1265 time, space and page faults. I didn't nest all those if()s for clarity 1266 and because I think the mode testing can be re-arranged 1st to test the 1267 commoner constructs 1st. Does anybody have statistics on this? 1268 1269 error messages 1270 1271 In future, we should be able to 'compose' error messages in a scratch area 1272 and give the user MUCH more informative error messages. Although this takes 1273 a little more code at run-time, it will make this module much more self- 1274 documenting. As an example of what sucks now: most error messages have 1275 hardwired into them the DEC VAX metacharacters "#^@" which are nothing like 1276 the Un*x characters "$`*", that most users will expect from this AS. 1277 1278 ---- 1279 1280 The input is a string, ending with '\0'. 1281 1282 We also require a 'hint' of what kind of operand is expected: so 1283 we can remind caller not to write into literals for instance. 1284 1285 The output is a skeletal instruction. 1286 1287 The algorithm has two parts. 1288 1. extract the syntactic features (parse off all the @^#-()+[] mode crud); 1289 2. express the @^#-()+[] as some parameters suited to further analysis. 1290 1291 2nd step is where we detect the googles of possible invalid combinations 1292 a human (or compiler) might write. Note that if we do a half-way 1293 decent assembler, we don't know how long to make (eg) displacement 1294 fields when we first meet them (because they may not have defined values). 1295 So we must wait until we know how many bits are needed for each address, 1296 then we can know both length and opcodes of instructions. 1297 For reason(s) above, we will pass to our caller a 'broken' instruction 1298 of these major components, from which our caller can generate instructions: 1299 - displacement length I^ S^ L^ B^ W^ unspecified 1300 - mode (many) 1301 - register R0-R15 or absent 1302 - index register R0-R15 or absent 1303 - expression text what we don't parse 1304 - error text(s) why we couldn't understand the operand 1305 1306 ---- 1307 1308 To decode output of this, test errtxt. If errtxt[0] == '\0', then 1309 we had no errors that prevented parsing. Also, if we ever report 1310 an internal bug, errtxt[0] is set non-zero. So one test tells you 1311 if the other outputs are to be taken seriously. 1312 1313 ---- 1314 1315 Dec defines the semantics of address modes (and values) 1316 by a two-letter code, explained here. 1317 1318 letter 1: access type 1319 1320 a address calculation - no data access, registers forbidden 1321 b branch displacement 1322 m read - let go of bus - write back "modify" 1323 r read 1324 v bit field address: like 'a' but registers are OK 1325 w write 1326 space no operator (eg ".long foo") [our convention] 1327 1328 letter 2: data type (i.e. width, alignment) 1329 1330 b byte 1331 d double precision floating point (D format) 1332 f single precision floating point (F format) 1333 g G format floating 1334 h H format floating 1335 l longword 1336 o octaword 1337 q quadword 1338 w word 1339 ? simple synthetic branch operand 1340 - unconditional synthetic JSB/JSR operand 1341 ! complex synthetic branch operand 1342 1343 The '-?!' letter 2's are not for external consumption. They are used 1344 for various assemblers. Generally, all unknown widths are assumed 0. 1345 We don't limit your choice of width character. 1346 1347 DEC operands are hard work to parse. For example, '@' as the first 1348 character means indirect (deferred) mode but elsewhere it is a shift 1349 operator. 1350 The long-winded explanation of how this is supposed to work is 1351 cancelled. Read a DEC vax manual. 1352 We try hard not to parse anything that MIGHT be part of the expression 1353 buried in that syntax. For example if we see @...(Rn) we don't check 1354 for '-' before the '(' because mode @-(Rn) does not exist. 1355 1356 After parsing we have: 1357 1358 at 1 if leading '@' (or Un*x '*') 1359 len takes one value from " bilsw". eg B^ -> 'b'. 1360 hash 1 if leading '#' (or Un*x '$') 1361 expr_begin, expr_end the expression we did not parse 1362 even though we don't interpret it, we make use 1363 of its presence or absence. 1364 sign -1: -(Rn) 0: absent +1: (Rn)+ 1365 paren 1 if () are around register 1366 reg major register number 0:15 -1 means absent 1367 ndx index register number 0:15 -1 means absent 1368 1369 Again, I dare not explain it: just trace ALL the code! 1370 1371 Summary of vip_op outputs. 1372 1373 mode reg len ndx 1374 (Rn) => @Rn 1375 {@}Rn 5+@ n ' ' optional 1376 branch operand 0 -1 ' ' -1 1377 S^#foo 0 -1 's' -1 1378 -(Rn) 7 n ' ' optional 1379 {@}(Rn)+ 8+@ n ' ' optional 1380 {@}#foo, no S^ 8+@ PC " i" optional 1381 {@}{q^}{(Rn)} 10+@+q option " bwl" optional */ 1382 1383 /* Dissect user-input 'optext' (which is something like "@B^foo@bar(AP)[FP]:") 1384 using the vop in vopP. vopP's vop_access and vop_width. We fill _ndx, _reg, 1385 _mode, _short, _warn, _error, _expr_begin, _expr_end and _nbytes. */ 1386 1387 static void 1388 vip_op (char *optext, struct vop *vopP) 1389 { 1390 /* Track operand text forward. */ 1391 char *p; 1392 /* Track operand text backward. */ 1393 char *q; 1394 /* 1 if leading '@' ('*') seen. */ 1395 int at; 1396 /* one of " bilsw" */ 1397 char len; 1398 /* 1 if leading '#' ('$') seen. */ 1399 int hash; 1400 /* -1, 0 or +1. */ 1401 int sign = 0; 1402 /* 1 if () surround register. */ 1403 int paren = 0; 1404 /* Register number, -1:absent. */ 1405 int reg = 0; 1406 /* Index register number -1:absent. */ 1407 int ndx = 0; 1408 /* Report illegal operand, ""==OK. */ 1409 /* " " is a FAKE error: means we won. */ 1410 /* ANY err that begins with ' ' is a fake. */ 1411 /* " " is converted to "" before return. */ 1412 const char *err; 1413 /* Warn about weird modes pf address. */ 1414 const char *wrn; 1415 /* Preserve q in case we backup. */ 1416 char *oldq = NULL; 1417 /* Build up 4-bit operand mode here. */ 1418 /* Note: index mode is in ndx, this is. */ 1419 /* The major mode of operand address. */ 1420 int mode = 0; 1421 /* Notice how we move wrong-arg-type bugs INSIDE this module: if we 1422 get the types wrong below, we lose at compile time rather than at 1423 lint or run time. */ 1424 char access_mode; /* vop_access. */ 1425 1426 access_mode = vopP->vop_access; 1427 /* None of our code bugs (yet), no user text errors, no warnings 1428 even. */ 1429 err = wrn = 0; 1430 1431 p = optext; 1432 1433 if (*p == ' ') /* Expect all whitespace reduced to ' '. */ 1434 p++; /* skip over whitespace */ 1435 1436 if ((at = INDIRECTP (*p)) != 0) 1437 { /* 1 if *p=='@'(or '*' for Un*x) */ 1438 p++; /* at is determined */ 1439 if (*p == ' ') /* Expect all whitespace reduced to ' '. */ 1440 p++; /* skip over whitespace */ 1441 } 1442 1443 /* This code is subtle. It tries to detect all legal (letter)'^' 1444 but it doesn't waste time explicitly testing for premature '\0' because 1445 this case is rejected as a mismatch against either (letter) or '^'. */ 1446 { 1447 char c; 1448 1449 c = *p; 1450 c = TOLOWER (c); 1451 if (DISPLENP (p[1]) && strchr ("bilws", len = c)) 1452 p += 2; /* Skip (letter) '^'. */ 1453 else /* No (letter) '^' seen. */ 1454 len = ' '; /* Len is determined. */ 1455 } 1456 1457 if (*p == ' ') /* Expect all whitespace reduced to ' '. */ 1458 p++; 1459 1460 if ((hash = IMMEDIATEP (*p)) != 0) /* 1 if *p=='#' ('$' for Un*x) */ 1461 p++; /* Hash is determined. */ 1462 1463 /* p points to what may be the beginning of an expression. 1464 We have peeled off the front all that is peelable. 1465 We know at, len, hash. 1466 1467 Lets point q at the end of the text and parse that (backwards). */ 1468 1469 for (q = p; *q; q++) 1470 ; 1471 q--; /* Now q points at last char of text. */ 1472 1473 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */ 1474 q--; 1475 1476 /* Reverse over whitespace, but don't. */ 1477 /* Run back over *p. */ 1478 1479 /* As a matter of policy here, we look for [Rn], although both Rn and S^# 1480 forbid [Rn]. This is because it is easy, and because only a sick 1481 cyborg would have [...] trailing an expression in a VAX-like assembler. 1482 A meticulous parser would first check for Rn followed by '(' or '[' 1483 and not parse a trailing ']' if it found another. We just ban expressions 1484 ending in ']'. */ 1485 if (*q == ']') 1486 { 1487 while (q >= p && *q != '[') 1488 q--; 1489 /* Either q<p or we got matching '['. */ 1490 if (q < p) 1491 err = _("no '[' to match ']'"); 1492 else 1493 { 1494 /* Confusers like "[]" will eventually lose with a bad register 1495 * name error. So again we don't need to check for early '\0'. */ 1496 if (q[3] == ']') 1497 ndx = vax_reg_parse (q[1], q[2], 0, 0); 1498 else if (q[4] == ']') 1499 ndx = vax_reg_parse (q[1], q[2], q[3], 0); 1500 else if (q[5] == ']') 1501 ndx = vax_reg_parse (q[1], q[2], q[3], q[4]); 1502 else 1503 ndx = -1; 1504 /* Since we saw a ']' we will demand a register name in the []. 1505 * If luser hasn't given us one: be rude. */ 1506 if (ndx < 0) 1507 err = _("bad register in []"); 1508 else if (ndx == PC) 1509 err = _("[PC] index banned"); 1510 else 1511 /* Point q just before "[...]". */ 1512 q--; 1513 } 1514 } 1515 else 1516 /* No ']', so no iNDeX register. */ 1517 ndx = -1; 1518 1519 /* If err = "..." then we lost: run away. 1520 Otherwise ndx == -1 if there was no "[...]". 1521 Otherwise, ndx is index register number, and q points before "[...]". */ 1522 1523 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */ 1524 q--; 1525 /* Reverse over whitespace, but don't. */ 1526 /* Run back over *p. */ 1527 if (!err || !*err) 1528 { 1529 /* no ()+ or -() seen yet */ 1530 sign = 0; 1531 1532 if (q > p + 3 && *q == '+' && q[-1] == ')') 1533 { 1534 sign = 1; /* we saw a ")+" */ 1535 q--; /* q points to ')' */ 1536 } 1537 1538 if (*q == ')' && q > p + 2) 1539 { 1540 paren = 1; /* assume we have "(...)" */ 1541 while (q >= p && *q != '(') 1542 q--; 1543 /* either q<p or we got matching '(' */ 1544 if (q < p) 1545 err = _("no '(' to match ')'"); 1546 else 1547 { 1548 /* Confusers like "()" will eventually lose with a bad register 1549 name error. So again we don't need to check for early '\0'. */ 1550 if (q[3] == ')') 1551 reg = vax_reg_parse (q[1], q[2], 0, 0); 1552 else if (q[4] == ')') 1553 reg = vax_reg_parse (q[1], q[2], q[3], 0); 1554 else if (q[5] == ')') 1555 reg = vax_reg_parse (q[1], q[2], q[3], q[4]); 1556 else 1557 reg = -1; 1558 /* Since we saw a ')' we will demand a register name in the ')'. 1559 This is nasty: why can't our hypothetical assembler permit 1560 parenthesised expressions? BECAUSE I AM LAZY! That is why. 1561 Abuse luser if we didn't spy a register name. */ 1562 if (reg < 0) 1563 { 1564 /* JF allow parenthesized expressions. I hope this works. */ 1565 paren = 0; 1566 while (*q != ')') 1567 q++; 1568 /* err = "unknown register in ()"; */ 1569 } 1570 else 1571 q--; /* point just before '(' of "(...)" */ 1572 /* If err == "..." then we lost. Run away. 1573 Otherwise if reg >= 0 then we saw (Rn). */ 1574 } 1575 /* If err == "..." then we lost. 1576 Otherwise paren==1 and reg = register in "()". */ 1577 } 1578 else 1579 paren = 0; 1580 /* If err == "..." then we lost. 1581 Otherwise, q points just before "(Rn)", if any. 1582 If there was a "(...)" then paren==1, and reg is the register. */ 1583 1584 /* We should only seek '-' of "-(...)" if: 1585 we saw "(...)" paren == 1 1586 we have no errors so far ! *err 1587 we did not see '+' of "(...)+" sign < 1 1588 We don't check len. We want a specific error message later if 1589 user tries "x^...-(Rn)". This is a feature not a bug. */ 1590 if (!err || !*err) 1591 { 1592 if (paren && sign < 1)/* !sign is adequate test */ 1593 { 1594 if (*q == '-') 1595 { 1596 sign = -1; 1597 q--; 1598 } 1599 } 1600 /* We have back-tracked over most 1601 of the crud at the end of an operand. 1602 Unless err, we know: sign, paren. If paren, we know reg. 1603 The last case is of an expression "Rn". 1604 This is worth hunting for if !err, !paren. 1605 We wouldn't be here if err. 1606 We remember to save q, in case we didn't want "Rn" anyway. */ 1607 if (!paren) 1608 { 1609 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */ 1610 q--; 1611 /* Reverse over whitespace, but don't. */ 1612 /* Run back over *p. */ 1613 /* Room for Rn or Rnn (include prefix) exactly? */ 1614 if (q > p && q < p + 4) 1615 reg = vax_reg_parse (p[0], p[1], 1616 q < p + 2 ? 0 : p[2], 1617 q < p + 3 ? 0 : p[3]); 1618 else 1619 reg = -1; /* Always comes here if no register at all. */ 1620 /* Here with a definitive reg value. */ 1621 if (reg >= 0) 1622 { 1623 oldq = q; 1624 q = p - 1; 1625 } 1626 } 1627 } 1628 } 1629 /* have reg. -1:absent; else 0:15. */ 1630 1631 /* We have: err, at, len, hash, ndx, sign, paren, reg. 1632 Also, any remaining expression is from *p through *q inclusive. 1633 Should there be no expression, q==p-1. So expression length = q-p+1. 1634 This completes the first part: parsing the operand text. */ 1635 1636 /* We now want to boil the data down, checking consistency on the way. 1637 We want: len, mode, reg, ndx, err, p, q, wrn, bug. 1638 We will deliver a 4-bit reg, and a 4-bit mode. */ 1639 1640 /* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance. 1641 1642 in: at ? 1643 len ? 1644 hash ? 1645 p:q ? 1646 sign ? 1647 paren ? 1648 reg ? 1649 ndx ? 1650 1651 out: mode 0 1652 reg -1 1653 len ' ' 1654 p:q whatever was input 1655 ndx -1 1656 err " " or error message, and other outputs trashed. */ 1657 /* Branch operands have restricted forms. */ 1658 if ((!err || !*err) && access_mode == 'b') 1659 { 1660 if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ') 1661 err = _("invalid branch operand"); 1662 else 1663 err = " "; 1664 } 1665 1666 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */ 1667 #ifdef NEVER 1668 /* Case of stand-alone operand. e.g. ".long foo" 1669 1670 in: at ? 1671 len ? 1672 hash ? 1673 p:q ? 1674 sign ? 1675 paren ? 1676 reg ? 1677 ndx ? 1678 1679 out: mode 0 1680 reg -1 1681 len ' ' 1682 p:q whatever was input 1683 ndx -1 1684 err " " or error message, and other outputs trashed. */ 1685 if ((!err || !*err) && access_mode == ' ') 1686 { 1687 if (at) 1688 err = _("address prohibits @"); 1689 else if (hash) 1690 err = _("address prohibits #"); 1691 else if (sign) 1692 { 1693 if (sign < 0) 1694 err = _("address prohibits -()"); 1695 else 1696 err = _("address prohibits ()+"); 1697 } 1698 else if (paren) 1699 err = _("address prohibits ()"); 1700 else if (ndx >= 0) 1701 err = _("address prohibits []"); 1702 else if (reg >= 0) 1703 err = _("address prohibits register"); 1704 else if (len != ' ') 1705 err = _("address prohibits displacement length specifier"); 1706 else 1707 { 1708 err = " "; /* succeed */ 1709 mode = 0; 1710 } 1711 } 1712 #endif 1713 1714 /* Case of S^#. 1715 1716 in: at 0 1717 len 's' definition 1718 hash 1 demand 1719 p:q demand not empty 1720 sign 0 by paren==0 1721 paren 0 by "()" scan logic because "S^" seen 1722 reg -1 or nn by mistake 1723 ndx -1 1724 1725 out: mode 0 1726 reg -1 1727 len 's' 1728 exp 1729 ndx -1 */ 1730 if ((!err || !*err) && len == 's') 1731 { 1732 if (!hash || paren || at || ndx >= 0) 1733 err = _("invalid operand of S^#"); 1734 else 1735 { 1736 if (reg >= 0) 1737 { 1738 /* Darn! we saw S^#Rnn ! put the Rnn back in 1739 expression. KLUDGE! Use oldq so we don't 1740 need to know exact length of reg name. */ 1741 q = oldq; 1742 reg = 0; 1743 } 1744 /* We have all the expression we will ever get. */ 1745 if (p > q) 1746 err = _("S^# needs expression"); 1747 else if (access_mode == 'r') 1748 { 1749 err = " "; /* WIN! */ 1750 mode = 0; 1751 } 1752 else 1753 err = _("S^# may only read-access"); 1754 } 1755 } 1756 1757 /* Case of -(Rn), which is weird case. 1758 1759 in: at 0 1760 len ' 1761 hash 0 1762 p:q q<p 1763 sign -1 by definition 1764 paren 1 by definition 1765 reg present by definition 1766 ndx optional 1767 1768 out: mode 7 1769 reg present 1770 len ' ' 1771 exp "" enforce empty expression 1772 ndx optional warn if same as reg. */ 1773 if ((!err || !*err) && sign < 0) 1774 { 1775 if (len != ' ' || hash || at || p <= q) 1776 err = _("invalid operand of -()"); 1777 else 1778 { 1779 err = " "; /* win */ 1780 mode = 7; 1781 if (reg == PC) 1782 wrn = _("-(PC) unpredictable"); 1783 else if (reg == ndx) 1784 wrn = _("[]index same as -()register: unpredictable"); 1785 } 1786 } 1787 1788 /* We convert "(Rn)" to "@Rn" for our convenience. 1789 (I hope this is convenient: has someone got a better way to parse this?) 1790 A side-effect of this is that "@Rn" is a valid operand. */ 1791 if (paren && !sign && !hash && !at && len == ' ' && p > q) 1792 { 1793 at = 1; 1794 paren = 0; 1795 } 1796 1797 /* Case of (Rn)+, which is slightly different. 1798 1799 in: at 1800 len ' ' 1801 hash 0 1802 p:q q<p 1803 sign +1 by definition 1804 paren 1 by definition 1805 reg present by definition 1806 ndx optional 1807 1808 out: mode 8+@ 1809 reg present 1810 len ' ' 1811 exp "" enforce empty expression 1812 ndx optional warn if same as reg. */ 1813 if ((!err || !*err) && sign > 0) 1814 { 1815 if (len != ' ' || hash || p <= q) 1816 err = _("invalid operand of ()+"); 1817 else 1818 { 1819 err = " "; /* win */ 1820 mode = 8 + (at ? 1 : 0); 1821 if (reg == PC) 1822 wrn = _("(PC)+ unpredictable"); 1823 else if (reg == ndx) 1824 wrn = _("[]index same as ()+register: unpredictable"); 1825 } 1826 } 1827 1828 /* Case of #, without S^. 1829 1830 in: at 1831 len ' ' or 'i' 1832 hash 1 by definition 1833 p:q 1834 sign 0 1835 paren 0 1836 reg absent 1837 ndx optional 1838 1839 out: mode 8+@ 1840 reg PC 1841 len ' ' or 'i' 1842 exp 1843 ndx optional. */ 1844 if ((!err || !*err) && hash) 1845 { 1846 if (len != 'i' && len != ' ') 1847 err = _("# conflicts length"); 1848 else if (paren) 1849 err = _("# bars register"); 1850 else 1851 { 1852 if (reg >= 0) 1853 { 1854 /* Darn! we saw #Rnn! Put the Rnn back into the expression. 1855 By using oldq, we don't need to know how long Rnn was. 1856 KLUDGE! */ 1857 q = oldq; 1858 reg = -1; /* No register any more. */ 1859 } 1860 err = " "; /* Win. */ 1861 1862 /* JF a bugfix, I think! */ 1863 if (at && access_mode == 'a') 1864 vopP->vop_nbytes = 4; 1865 1866 mode = (at ? 9 : 8); 1867 reg = PC; 1868 if ((access_mode == 'm' || access_mode == 'w') && !at) 1869 wrn = _("writing or modifying # is unpredictable"); 1870 } 1871 } 1872 /* If !*err, then sign == 0 1873 hash == 0 */ 1874 1875 /* Case of Rn. We separate this one because it has a few special 1876 errors the remaining modes lack. 1877 1878 in: at optional 1879 len ' ' 1880 hash 0 by program logic 1881 p:q empty 1882 sign 0 by program logic 1883 paren 0 by definition 1884 reg present by definition 1885 ndx optional 1886 1887 out: mode 5+@ 1888 reg present 1889 len ' ' enforce no length 1890 exp "" enforce empty expression 1891 ndx optional warn if same as reg. */ 1892 if ((!err || !*err) && !paren && reg >= 0) 1893 { 1894 if (len != ' ') 1895 err = _("length not needed"); 1896 else if (at) 1897 { 1898 err = " "; /* win */ 1899 mode = 6; /* @Rn */ 1900 } 1901 else if (ndx >= 0) 1902 err = _("can't []index a register, because it has no address"); 1903 else if (access_mode == 'a') 1904 err = _("a register has no address"); 1905 else 1906 { 1907 /* Idea here is to detect from length of datum 1908 and from register number if we will touch PC. 1909 Warn if we do. 1910 vop_nbytes is number of bytes in operand. 1911 Compute highest byte affected, compare to PC0. */ 1912 if ((vopP->vop_nbytes + reg * 4) > 60) 1913 wrn = _("PC part of operand unpredictable"); 1914 err = " "; /* win */ 1915 mode = 5; /* Rn */ 1916 } 1917 } 1918 /* If !*err, sign == 0 1919 hash == 0 1920 paren == 1 OR reg==-1 */ 1921 1922 /* Rest of cases fit into one bunch. 1923 1924 in: at optional 1925 len ' ' or 'b' or 'w' or 'l' 1926 hash 0 by program logic 1927 p:q expected (empty is not an error) 1928 sign 0 by program logic 1929 paren optional 1930 reg optional 1931 ndx optional 1932 1933 out: mode 10 + @ + len 1934 reg optional 1935 len ' ' or 'b' or 'w' or 'l' 1936 exp maybe empty 1937 ndx optional warn if same as reg. */ 1938 if (!err || !*err) 1939 { 1940 err = " "; /* win (always) */ 1941 mode = 10 + (at ? 1 : 0); 1942 switch (len) 1943 { 1944 case 'l': 1945 mode += 2; 1946 case 'w': 1947 mode += 2; 1948 case ' ': /* Assumed B^ until our caller changes it. */ 1949 case 'b': 1950 break; 1951 } 1952 } 1953 1954 /* here with completely specified mode 1955 len 1956 reg 1957 expression p,q 1958 ndx. */ 1959 1960 if (*err == ' ') 1961 err = 0; /* " " is no longer an error. */ 1962 1963 vopP->vop_mode = mode; 1964 vopP->vop_reg = reg; 1965 vopP->vop_short = len; 1966 vopP->vop_expr_begin = p; 1967 vopP->vop_expr_end = q; 1968 vopP->vop_ndx = ndx; 1969 vopP->vop_error = err; 1970 vopP->vop_warn = wrn; 1971 } 1972 1973 /* This converts a string into a vax instruction. 1974 The string must be a bare single instruction in dec-vax (with BSD4 frobs) 1975 format. 1976 It provides some error messages: at most one fatal error message (which 1977 stops the scan) and at most one warning message for each operand. 1978 The vax instruction is returned in exploded form, since we have no 1979 knowledge of how you parse (or evaluate) your expressions. 1980 We do however strip off and decode addressing modes and operation 1981 mnemonic. 1982 1983 The exploded instruction is returned to a struct vit of your choice. 1984 #include "vax-inst.h" to know what a struct vit is. 1985 1986 This function's value is a string. If it is not "" then an internal 1987 logic error was found: read this code to assign meaning to the string. 1988 No argument string should generate such an error string: 1989 it means a bug in our code, not in the user's text. 1990 1991 You MUST have called vip_begin() once before using this function. */ 1992 1993 static void 1994 vip (struct vit *vitP, /* We build an exploded instruction here. */ 1995 char *instring) /* Text of a vax instruction: we modify. */ 1996 { 1997 /* How to bit-encode this opcode. */ 1998 struct vot_wot *vwP; 1999 /* 1/skip whitespace.2/scan vot_how */ 2000 char *p; 2001 char *q; 2002 /* counts number of operands seen */ 2003 unsigned char count; 2004 /* scan operands in struct vit */ 2005 struct vop *operandp; 2006 /* error over all operands */ 2007 const char *alloperr; 2008 /* Remember char, (we clobber it with '\0' temporarily). */ 2009 char c; 2010 /* Op-code of this instruction. */ 2011 vax_opcodeT oc; 2012 2013 if (*instring == ' ') 2014 ++instring; 2015 2016 /* MUST end in end-of-string or exactly 1 space. */ 2017 for (p = instring; *p && *p != ' '; p++) 2018 ; 2019 2020 /* Scanned up to end of operation-code. */ 2021 /* Operation-code is ended with whitespace. */ 2022 if (p - instring == 0) 2023 { 2024 vitP->vit_error = _("No operator"); 2025 count = 0; 2026 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode)); 2027 } 2028 else 2029 { 2030 c = *p; 2031 *p = '\0'; 2032 /* Here with instring pointing to what better be an op-name, and p 2033 pointing to character just past that. 2034 We trust instring points to an op-name, with no whitespace. */ 2035 vwP = (struct vot_wot *) hash_find (op_hash, instring); 2036 /* Restore char after op-code. */ 2037 *p = c; 2038 if (vwP == 0) 2039 { 2040 vitP->vit_error = _("Unknown operator"); 2041 count = 0; 2042 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode)); 2043 } 2044 else 2045 { 2046 /* We found a match! So let's pick up as many operands as the 2047 instruction wants, and even gripe if there are too many. 2048 We expect comma to separate each operand. 2049 We let instring track the text, while p tracks a part of the 2050 struct vot. */ 2051 const char *howp; 2052 /* The lines below know about 2-byte opcodes starting FD,FE or FF. 2053 They also understand synthetic opcodes. Note: 2054 we return 32 bits of opcode, including bucky bits, BUT 2055 an opcode length is either 8 or 16 bits for vit_opcode_nbytes. */ 2056 oc = vwP->vot_code; /* The op-code. */ 2057 vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1; 2058 md_number_to_chars (vitP->vit_opcode, oc, 4); 2059 count = 0; /* No operands seen yet. */ 2060 instring = p; /* Point just past operation code. */ 2061 alloperr = ""; 2062 for (howp = vwP->vot_how, operandp = vitP->vit_operand; 2063 !(alloperr && *alloperr) && *howp; 2064 operandp++, howp += 2) 2065 { 2066 /* Here to parse one operand. Leave instring pointing just 2067 past any one ',' that marks the end of this operand. */ 2068 if (!howp[1]) 2069 as_fatal (_("odd number of bytes in operand description")); 2070 else if (*instring) 2071 { 2072 for (q = instring; (c = *q) && c != ','; q++) 2073 ; 2074 /* Q points to ',' or '\0' that ends argument. C is that 2075 character. */ 2076 *q = 0; 2077 operandp->vop_width = howp[1]; 2078 operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]]; 2079 operandp->vop_access = howp[0]; 2080 vip_op (instring, operandp); 2081 *q = c; /* Restore input text. */ 2082 if (operandp->vop_error) 2083 alloperr = _("Bad operand"); 2084 instring = q + (c ? 1 : 0); /* Next operand (if any). */ 2085 count++; /* Won another argument, may have an operr. */ 2086 } 2087 else 2088 alloperr = _("Not enough operands"); 2089 } 2090 if (!*alloperr) 2091 { 2092 if (*instring == ' ') 2093 instring++; 2094 if (*instring) 2095 alloperr = _("Too many operands"); 2096 } 2097 vitP->vit_error = alloperr; 2098 } 2099 } 2100 vitP->vit_operands = count; 2101 } 2102 2103 #ifdef test 2104 2105 /* Test program for above. */ 2106 2107 struct vit myvit; /* Build an exploded vax instruction here. */ 2108 char answer[100]; /* Human types a line of vax assembler here. */ 2109 char *mybug; /* "" or an internal logic diagnostic. */ 2110 int mycount; /* Number of operands. */ 2111 struct vop *myvop; /* Scan operands from myvit. */ 2112 int mysynth; /* 1 means want synthetic opcodes. */ 2113 char my_immediate[200]; 2114 char my_indirect[200]; 2115 char my_displen[200]; 2116 2117 int 2118 main (void) 2119 { 2120 char *p; 2121 2122 printf ("0 means no synthetic instructions. "); 2123 printf ("Value for vip_begin? "); 2124 gets (answer); 2125 sscanf (answer, "%d", &mysynth); 2126 printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not"); 2127 printf ("enter immediate symbols eg enter # "); 2128 gets (my_immediate); 2129 printf ("enter indirect symbols eg enter @ "); 2130 gets (my_indirect); 2131 printf ("enter displen symbols eg enter ^ "); 2132 gets (my_displen); 2133 2134 if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen)) 2135 error ("vip_begin=%s", p); 2136 2137 printf ("An empty input line will quit you from the vax instruction parser\n"); 2138 for (;;) 2139 { 2140 printf ("vax instruction: "); 2141 fflush (stdout); 2142 gets (answer); 2143 if (!*answer) 2144 break; /* Out of for each input text loop. */ 2145 2146 vip (& myvit, answer); 2147 if (*myvit.vit_error) 2148 printf ("ERR:\"%s\"\n", myvit.vit_error); 2149 2150 printf ("opcode="); 2151 for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode; 2152 mycount; 2153 mycount--, p++) 2154 printf ("%02x ", *p & 0xFF); 2155 2156 printf (" operand count=%d.\n", mycount = myvit.vit_operands); 2157 for (myvop = myvit.vit_operand; mycount; mycount--, myvop++) 2158 { 2159 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"", 2160 myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx, 2161 myvop->vop_short, myvop->vop_access, myvop->vop_width, 2162 myvop->vop_nbytes); 2163 for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++) 2164 putchar (*p); 2165 2166 printf ("\"\n"); 2167 if (myvop->vop_error) 2168 printf (" err:\"%s\"\n", myvop->vop_error); 2169 2170 if (myvop->vop_warn) 2171 printf (" wrn:\"%s\"\n", myvop->vop_warn); 2172 } 2173 } 2174 vip_end (); 2175 exit (EXIT_SUCCESS); 2176 } 2177 2178 #endif 2179 2180 #ifdef TEST /* #Define to use this testbed. */ 2181 2182 /* Follows a test program for this function. 2183 We declare arrays non-local in case some of our tiny-minded machines 2184 default to small stacks. Also, helps with some debuggers. */ 2185 2186 char answer[100]; /* Human types into here. */ 2187 char *p; /* */ 2188 char *myerr; 2189 char *mywrn; 2190 char *mybug; 2191 char myaccess; 2192 char mywidth; 2193 char mymode; 2194 char myreg; 2195 char mylen; 2196 char *myleft; 2197 char *myright; 2198 char myndx; 2199 int my_operand_length; 2200 char my_immediate[200]; 2201 char my_indirect[200]; 2202 char my_displen[200]; 2203 2204 int 2205 main (void) 2206 { 2207 printf ("enter immediate symbols eg enter # "); 2208 gets (my_immediate); 2209 printf ("enter indirect symbols eg enter @ "); 2210 gets (my_indirect); 2211 printf ("enter displen symbols eg enter ^ "); 2212 gets (my_displen); 2213 vip_op_defaults (my_immediate, my_indirect, my_displen); 2214 2215 for (;;) 2216 { 2217 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : "); 2218 fflush (stdout); 2219 gets (answer); 2220 if (!answer[0]) 2221 exit (EXIT_SUCCESS); 2222 myaccess = answer[0]; 2223 mywidth = answer[1]; 2224 switch (mywidth) 2225 { 2226 case 'b': 2227 my_operand_length = 1; 2228 break; 2229 case 'd': 2230 my_operand_length = 8; 2231 break; 2232 case 'f': 2233 my_operand_length = 4; 2234 break; 2235 case 'g': 2236 my_operand_length = 16; 2237 break; 2238 case 'h': 2239 my_operand_length = 32; 2240 break; 2241 case 'l': 2242 my_operand_length = 4; 2243 break; 2244 case 'o': 2245 my_operand_length = 16; 2246 break; 2247 case 'q': 2248 my_operand_length = 8; 2249 break; 2250 case 'w': 2251 my_operand_length = 2; 2252 break; 2253 case '!': 2254 case '?': 2255 case '-': 2256 my_operand_length = 0; 2257 break; 2258 2259 default: 2260 my_operand_length = 2; 2261 printf ("I dn't understand access width %c\n", mywidth); 2262 break; 2263 } 2264 printf ("VAX assembler instruction operand: "); 2265 fflush (stdout); 2266 gets (answer); 2267 mybug = vip_op (answer, myaccess, mywidth, my_operand_length, 2268 &mymode, &myreg, &mylen, &myleft, &myright, &myndx, 2269 &myerr, &mywrn); 2270 if (*myerr) 2271 { 2272 printf ("error: \"%s\"\n", myerr); 2273 if (*mybug) 2274 printf (" bug: \"%s\"\n", mybug); 2275 } 2276 else 2277 { 2278 if (*mywrn) 2279 printf ("warning: \"%s\"\n", mywrn); 2280 mumble ("mode", mymode); 2281 mumble ("register", myreg); 2282 mumble ("index", myndx); 2283 printf ("width:'%c' ", mylen); 2284 printf ("expression: \""); 2285 while (myleft <= myright) 2286 putchar (*myleft++); 2287 printf ("\"\n"); 2288 } 2289 } 2290 } 2291 2292 void 2293 mumble (char *text, int value) 2294 { 2295 printf ("%s:", text); 2296 if (value >= 0) 2297 printf ("%xx", value); 2298 else 2299 printf ("ABSENT"); 2300 printf (" "); 2301 } 2302 2303 #endif 2304 2305 int md_short_jump_size = 3; 2306 int md_long_jump_size = 6; 2307 2308 void 2309 md_create_short_jump (char *ptr, 2310 addressT from_addr, 2311 addressT to_addr ATTRIBUTE_UNUSED, 2312 fragS *frag ATTRIBUTE_UNUSED, 2313 symbolS *to_symbol ATTRIBUTE_UNUSED) 2314 { 2315 valueT offset; 2316 2317 /* This former calculation was off by two: 2318 offset = to_addr - (from_addr + 1); 2319 We need to account for the one byte instruction and also its 2320 two byte operand. */ 2321 offset = to_addr - (from_addr + 1 + 2); 2322 *ptr++ = VAX_BRW; /* Branch with word (16 bit) offset. */ 2323 md_number_to_chars (ptr, offset, 2); 2324 } 2325 2326 void 2327 md_create_long_jump (char *ptr, 2328 addressT from_addr ATTRIBUTE_UNUSED, 2329 addressT to_addr, 2330 fragS *frag, 2331 symbolS *to_symbol) 2332 { 2333 valueT offset; 2334 2335 offset = to_addr - S_GET_VALUE (to_symbol); 2336 *ptr++ = VAX_JMP; /* Arbitrary jump. */ 2337 *ptr++ = VAX_ABSOLUTE_MODE; 2338 md_number_to_chars (ptr, offset, 4); 2339 fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC); 2340 } 2341 2342 #ifdef OBJ_VMS 2343 const char *md_shortopts = "d:STt:V+1h:Hv::"; 2344 #elif defined(OBJ_ELF) 2345 const char *md_shortopts = "d:STt:VkKQ:"; 2346 #else 2347 const char *md_shortopts = "d:STt:V"; 2348 #endif 2349 struct option md_longopts[] = 2350 { 2351 #ifdef OBJ_ELF 2352 #define OPTION_PIC (OPTION_MD_BASE) 2353 { "pic", no_argument, NULL, OPTION_PIC }, 2354 #endif 2355 { NULL, no_argument, NULL, 0 } 2356 }; 2357 size_t md_longopts_size = sizeof (md_longopts); 2358 2359 int 2360 md_parse_option (int c, char *arg) 2361 { 2362 switch (c) 2363 { 2364 case 'S': 2365 as_warn (_("SYMBOL TABLE not implemented")); 2366 break; 2367 2368 case 'T': 2369 as_warn (_("TOKEN TRACE not implemented")); 2370 break; 2371 2372 case 'd': 2373 as_warn (_("Displacement length %s ignored!"), arg); 2374 break; 2375 2376 case 't': 2377 as_warn (_("I don't need or use temp. file \"%s\"."), arg); 2378 break; 2379 2380 case 'V': 2381 as_warn (_("I don't use an interpass file! -V ignored")); 2382 break; 2383 2384 #ifdef OBJ_VMS 2385 case '+': /* For g++. Hash any name > 31 chars long. */ 2386 flag_hash_long_names = 1; 2387 break; 2388 2389 case '1': /* For backward compatibility. */ 2390 flag_one = 1; 2391 break; 2392 2393 case 'H': /* Show new symbol after hash truncation. */ 2394 flag_show_after_trunc = 1; 2395 break; 2396 2397 case 'h': /* No hashing of mixed-case names. */ 2398 { 2399 extern char vms_name_mapping; 2400 vms_name_mapping = atoi (arg); 2401 flag_no_hash_mixed_case = 1; 2402 } 2403 break; 2404 2405 case 'v': 2406 { 2407 extern char *compiler_version_string; 2408 2409 if (!arg || !*arg || access (arg, 0) == 0) 2410 return 0; /* Have caller show the assembler version. */ 2411 compiler_version_string = arg; 2412 } 2413 break; 2414 #endif 2415 2416 #ifdef OBJ_ELF 2417 case OPTION_PIC: 2418 case 'k': 2419 flag_want_pic = 1; 2420 break; /* -pic, Position Independent Code. */ 2421 2422 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment 2423 section should be emitted or not. FIXME: Not implemented. */ 2424 case 'Q': 2425 break; 2426 #endif 2427 2428 default: 2429 return 0; 2430 } 2431 2432 return 1; 2433 } 2434 2435 void 2436 md_show_usage (FILE *stream) 2437 { 2438 fprintf (stream, _("\ 2439 VAX options:\n\ 2440 -d LENGTH ignored\n\ 2441 -J ignored\n\ 2442 -S ignored\n\ 2443 -t FILE ignored\n\ 2444 -T ignored\n\ 2445 -V ignored\n")); 2446 #ifdef OBJ_VMS 2447 fprintf (stream, _("\ 2448 VMS options:\n\ 2449 -+ hash encode names longer than 31 characters\n\ 2450 -1 `const' handling compatible with gcc 1.x\n\ 2451 -H show new symbol after hash truncation\n\ 2452 -h NUM don't hash mixed-case names, and adjust case:\n\ 2453 0 = upper, 2 = lower, 3 = preserve case\n\ 2454 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n")); 2455 #endif 2456 } 2457 2458 /* We have no need to default values of symbols. */ 2459 2460 symbolS * 2461 md_undefined_symbol (char *name ATTRIBUTE_UNUSED) 2462 { 2463 return NULL; 2464 } 2465 2466 /* Round up a section size to the appropriate boundary. */ 2467 valueT 2468 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size) 2469 { 2470 /* Byte alignment is fine */ 2471 return size; 2472 } 2473 2474 /* Exactly what point is a PC-relative offset relative TO? 2475 On the vax, they're relative to the address of the offset, plus 2476 its size. */ 2477 long 2478 md_pcrel_from (fixS *fixP) 2479 { 2480 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address; 2481 } 2482 2483 arelent * 2484 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp) 2485 { 2486 arelent *reloc; 2487 bfd_reloc_code_real_type code; 2488 2489 if (fixp->fx_tcbit) 2490 abort (); 2491 2492 if (fixp->fx_r_type != BFD_RELOC_NONE) 2493 { 2494 code = fixp->fx_r_type; 2495 2496 if (fixp->fx_pcrel) 2497 { 2498 switch (code) 2499 { 2500 case BFD_RELOC_8_PCREL: 2501 case BFD_RELOC_16_PCREL: 2502 case BFD_RELOC_32_PCREL: 2503 #ifdef OBJ_ELF 2504 case BFD_RELOC_8_GOT_PCREL: 2505 case BFD_RELOC_16_GOT_PCREL: 2506 case BFD_RELOC_32_GOT_PCREL: 2507 case BFD_RELOC_8_PLT_PCREL: 2508 case BFD_RELOC_16_PLT_PCREL: 2509 case BFD_RELOC_32_PLT_PCREL: 2510 #endif 2511 break; 2512 default: 2513 as_bad_where (fixp->fx_file, fixp->fx_line, 2514 _("Cannot make %s relocation PC relative"), 2515 bfd_get_reloc_code_name (code)); 2516 } 2517 } 2518 } 2519 else 2520 { 2521 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL)) 2522 switch (F (fixp->fx_size, fixp->fx_pcrel)) 2523 { 2524 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break 2525 MAP (1, 0, BFD_RELOC_8); 2526 MAP (2, 0, BFD_RELOC_16); 2527 MAP (4, 0, BFD_RELOC_32); 2528 MAP (1, 1, BFD_RELOC_8_PCREL); 2529 MAP (2, 1, BFD_RELOC_16_PCREL); 2530 MAP (4, 1, BFD_RELOC_32_PCREL); 2531 default: 2532 abort (); 2533 } 2534 } 2535 #undef F 2536 #undef MAP 2537 2538 reloc = xmalloc (sizeof (arelent)); 2539 reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *)); 2540 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 2541 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; 2542 #ifndef OBJ_ELF 2543 if (fixp->fx_pcrel) 2544 reloc->addend = fixp->fx_addnumber; 2545 else 2546 reloc->addend = 0; 2547 #else 2548 reloc->addend = fixp->fx_offset; 2549 #endif 2550 2551 reloc->howto = bfd_reloc_type_lookup (stdoutput, code); 2552 gas_assert (reloc->howto != 0); 2553 2554 return reloc; 2555 } 2556 2557 /* vax:md_assemble() emit frags for 1 instruction given in textual form. */ 2558 void 2559 md_assemble (char *instruction_string) 2560 { 2561 /* Non-zero if operand expression's segment is not known yet. */ 2562 int is_undefined; 2563 /* Non-zero if operand expression's segment is absolute. */ 2564 int is_absolute; 2565 int length_code; 2566 char *p; 2567 /* An operand. Scans all operands. */ 2568 struct vop *operandP; 2569 char *save_input_line_pointer; 2570 /* What used to live after an expression. */ 2571 char c_save; 2572 /* 1: instruction_string bad for all passes. */ 2573 int goofed; 2574 /* Points to slot just after last operand. */ 2575 struct vop *end_operandP; 2576 /* Points to expression values for this operand. */ 2577 expressionS *expP; 2578 segT *segP; 2579 2580 /* These refer to an instruction operand expression. */ 2581 /* Target segment of the address. */ 2582 segT to_seg; 2583 valueT this_add_number; 2584 /* Positive (minuend) symbol. */ 2585 symbolS *this_add_symbol; 2586 /* As a number. */ 2587 long opcode_as_number; 2588 /* Least significant byte 1st. */ 2589 char *opcode_as_chars; 2590 /* As an array of characters. */ 2591 /* Least significant byte 1st */ 2592 char *opcode_low_byteP; 2593 /* length (bytes) meant by vop_short. */ 2594 int length; 2595 /* 0, or 1 if '@' is in addressing mode. */ 2596 int at; 2597 /* From vop_nbytes: vax_operand_width (in bytes) */ 2598 int nbytes; 2599 FLONUM_TYPE *floatP; 2600 LITTLENUM_TYPE literal_float[8]; 2601 /* Big enough for any floating point literal. */ 2602 2603 vip (&v, instruction_string); 2604 2605 /* Now we try to find as many as_warn()s as we can. If we do any as_warn()s 2606 then goofed=1. Notice that we don't make any frags yet. 2607 Should goofed be 1, then this instruction will wedge in any pass, 2608 and we can safely flush it, without causing interpass symbol phase 2609 errors. That is, without changing label values in different passes. */ 2610 if ((goofed = (*v.vit_error)) != 0) 2611 { 2612 as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error); 2613 } 2614 /* We need to use expression() and friends, which require us to diddle 2615 input_line_pointer. So we save it and restore it later. */ 2616 save_input_line_pointer = input_line_pointer; 2617 for (operandP = v.vit_operand, 2618 expP = exp_of_operand, 2619 segP = seg_of_operand, 2620 floatP = float_operand, 2621 end_operandP = v.vit_operand + v.vit_operands; 2622 2623 operandP < end_operandP; 2624 2625 operandP++, expP++, segP++, floatP++) 2626 { 2627 if (operandP->vop_error) 2628 { 2629 as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error); 2630 goofed = 1; 2631 } 2632 else 2633 { 2634 /* Statement has no syntax goofs: let's sniff the expression. */ 2635 int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */ 2636 2637 input_line_pointer = operandP->vop_expr_begin; 2638 c_save = operandP->vop_expr_end[1]; 2639 operandP->vop_expr_end[1] = '\0'; 2640 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */ 2641 *segP = expression (expP); 2642 switch (expP->X_op) 2643 { 2644 case O_absent: 2645 /* for BSD4.2 compatibility, missing expression is absolute 0 */ 2646 expP->X_op = O_constant; 2647 expP->X_add_number = 0; 2648 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol, 2649 X_add_symbol to any particular value. But, we will program 2650 defensively. Since this situation occurs rarely so it costs 2651 us little to do, and stops Dean worrying about the origin of 2652 random bits in expressionS's. */ 2653 expP->X_add_symbol = NULL; 2654 expP->X_op_symbol = NULL; 2655 break; 2656 2657 case O_symbol: 2658 case O_constant: 2659 break; 2660 2661 default: 2662 /* Major bug. We can't handle the case of a 2663 SEG_OP expression in a VIT_OPCODE_SYNTHETIC 2664 variable-length instruction. 2665 We don't have a frag type that is smart enough to 2666 relax a SEG_OP, and so we just force all 2667 SEG_OPs to behave like SEG_PASS1s. 2668 Clearly, if there is a demand we can invent a new or 2669 modified frag type and then coding up a frag for this 2670 case will be easy. SEG_OP was invented for the 2671 .words after a CASE opcode, and was never intended for 2672 instruction operands. */ 2673 need_pass_2 = 1; 2674 as_fatal (_("Can't relocate expression")); 2675 break; 2676 2677 case O_big: 2678 /* Preserve the bits. */ 2679 if (expP->X_add_number > 0) 2680 { 2681 bignum_copy (generic_bignum, expP->X_add_number, 2682 floatP->low, SIZE_OF_LARGE_NUMBER); 2683 } 2684 else 2685 { 2686 know (expP->X_add_number < 0); 2687 flonum_copy (&generic_floating_point_number, 2688 floatP); 2689 if (strchr ("s i", operandP->vop_short)) 2690 { 2691 /* Could possibly become S^# */ 2692 flonum_gen2vax (-expP->X_add_number, floatP, literal_float); 2693 switch (-expP->X_add_number) 2694 { 2695 case 'f': 2696 can_be_short = 2697 (literal_float[0] & 0xFC0F) == 0x4000 2698 && literal_float[1] == 0; 2699 break; 2700 2701 case 'd': 2702 can_be_short = 2703 (literal_float[0] & 0xFC0F) == 0x4000 2704 && literal_float[1] == 0 2705 && literal_float[2] == 0 2706 && literal_float[3] == 0; 2707 break; 2708 2709 case 'g': 2710 can_be_short = 2711 (literal_float[0] & 0xFF81) == 0x4000 2712 && literal_float[1] == 0 2713 && literal_float[2] == 0 2714 && literal_float[3] == 0; 2715 break; 2716 2717 case 'h': 2718 can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000 2719 && (literal_float[1] & 0xE000) == 0 2720 && literal_float[2] == 0 2721 && literal_float[3] == 0 2722 && literal_float[4] == 0 2723 && literal_float[5] == 0 2724 && literal_float[6] == 0 2725 && literal_float[7] == 0); 2726 break; 2727 2728 default: 2729 BAD_CASE (-expP->X_add_number); 2730 break; 2731 } 2732 } 2733 } 2734 2735 if (operandP->vop_short == 's' 2736 || operandP->vop_short == 'i' 2737 || (operandP->vop_short == ' ' 2738 && operandP->vop_reg == 0xF 2739 && (operandP->vop_mode & 0xE) == 0x8)) 2740 { 2741 /* Saw a '#'. */ 2742 if (operandP->vop_short == ' ') 2743 { 2744 /* We must chose S^ or I^. */ 2745 if (expP->X_add_number > 0) 2746 { 2747 /* Bignum: Short literal impossible. */ 2748 operandP->vop_short = 'i'; 2749 operandP->vop_mode = 8; 2750 operandP->vop_reg = 0xF; /* VAX PC. */ 2751 } 2752 else 2753 { 2754 /* Flonum: Try to do it. */ 2755 if (can_be_short) 2756 { 2757 operandP->vop_short = 's'; 2758 operandP->vop_mode = 0; 2759 operandP->vop_ndx = -1; 2760 operandP->vop_reg = -1; 2761 expP->X_op = O_constant; 2762 } 2763 else 2764 { 2765 operandP->vop_short = 'i'; 2766 operandP->vop_mode = 8; 2767 operandP->vop_reg = 0xF; /* VAX PC */ 2768 } 2769 } /* bignum or flonum ? */ 2770 } /* if #, but no S^ or I^ seen. */ 2771 /* No more ' ' case: either 's' or 'i'. */ 2772 if (operandP->vop_short == 's') 2773 { 2774 /* Wants to be a short literal. */ 2775 if (expP->X_add_number > 0) 2776 { 2777 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed.")); 2778 operandP->vop_short = 'i'; 2779 operandP->vop_mode = 8; 2780 operandP->vop_reg = 0xF; /* VAX PC. */ 2781 } 2782 else 2783 { 2784 if (!can_be_short) 2785 { 2786 as_warn (_("Can't do flonum short literal: immediate mode used.")); 2787 operandP->vop_short = 'i'; 2788 operandP->vop_mode = 8; 2789 operandP->vop_reg = 0xF; /* VAX PC. */ 2790 } 2791 else 2792 { 2793 /* Encode short literal now. */ 2794 int temp = 0; 2795 2796 switch (-expP->X_add_number) 2797 { 2798 case 'f': 2799 case 'd': 2800 temp = literal_float[0] >> 4; 2801 break; 2802 2803 case 'g': 2804 temp = literal_float[0] >> 1; 2805 break; 2806 2807 case 'h': 2808 temp = ((literal_float[0] << 3) & 070) 2809 | ((literal_float[1] >> 13) & 07); 2810 break; 2811 2812 default: 2813 BAD_CASE (-expP->X_add_number); 2814 break; 2815 } 2816 2817 floatP->low[0] = temp & 077; 2818 floatP->low[1] = 0; 2819 } 2820 } 2821 } 2822 else 2823 { 2824 /* I^# seen: set it up if float. */ 2825 if (expP->X_add_number < 0) 2826 { 2827 memcpy (floatP->low, literal_float, sizeof (literal_float)); 2828 } 2829 } /* if S^# seen. */ 2830 } 2831 else 2832 { 2833 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"), 2834 (expP->X_add_number = 0x80000000L)); 2835 /* Chosen so luser gets the most offset bits to patch later. */ 2836 } 2837 expP->X_add_number = floatP->low[0] 2838 | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS); 2839 2840 /* For the O_big case we have: 2841 If vop_short == 's' then a short floating literal is in the 2842 lowest 6 bits of floatP -> low [0], which is 2843 big_operand_bits [---] [0]. 2844 If vop_short == 'i' then the appropriate number of elements 2845 of big_operand_bits [---] [...] are set up with the correct 2846 bits. 2847 Also, just in case width is byte word or long, we copy the lowest 2848 32 bits of the number to X_add_number. */ 2849 break; 2850 } 2851 if (input_line_pointer != operandP->vop_expr_end + 1) 2852 { 2853 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer); 2854 goofed = 1; 2855 } 2856 operandP->vop_expr_end[1] = c_save; 2857 } 2858 } 2859 2860 input_line_pointer = save_input_line_pointer; 2861 2862 if (need_pass_2 || goofed) 2863 return; 2864 2865 dwarf2_emit_insn (0); 2866 /* Emit op-code. */ 2867 /* Remember where it is, in case we want to modify the op-code later. */ 2868 opcode_low_byteP = frag_more (v.vit_opcode_nbytes); 2869 memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes); 2870 opcode_as_chars = v.vit_opcode; 2871 opcode_as_number = md_chars_to_number ((unsigned char *) opcode_as_chars, 4); 2872 for (operandP = v.vit_operand, 2873 expP = exp_of_operand, 2874 segP = seg_of_operand, 2875 floatP = float_operand, 2876 end_operandP = v.vit_operand + v.vit_operands; 2877 2878 operandP < end_operandP; 2879 2880 operandP++, 2881 floatP++, 2882 segP++, 2883 expP++) 2884 { 2885 if (operandP->vop_ndx >= 0) 2886 { 2887 /* Indexed addressing byte. */ 2888 /* Legality of indexed mode already checked: it is OK. */ 2889 FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx); 2890 } /* if(vop_ndx>=0) */ 2891 2892 /* Here to make main operand frag(s). */ 2893 this_add_number = expP->X_add_number; 2894 this_add_symbol = expP->X_add_symbol; 2895 to_seg = *segP; 2896 is_undefined = (to_seg == undefined_section); 2897 is_absolute = (to_seg == absolute_section); 2898 at = operandP->vop_mode & 1; 2899 length = (operandP->vop_short == 'b' 2900 ? 1 : (operandP->vop_short == 'w' 2901 ? 2 : (operandP->vop_short == 'l' 2902 ? 4 : 0))); 2903 nbytes = operandP->vop_nbytes; 2904 if (operandP->vop_access == 'b') 2905 { 2906 if (to_seg == now_seg || is_undefined) 2907 { 2908 /* If is_undefined, then it might BECOME now_seg. */ 2909 if (nbytes) 2910 { 2911 p = frag_more (nbytes); 2912 fix_new (frag_now, p - frag_now->fr_literal, nbytes, 2913 this_add_symbol, this_add_number, 1, NO_RELOC); 2914 } 2915 else 2916 { 2917 /* to_seg==now_seg || to_seg == SEG_UNKNOWN */ 2918 /* nbytes==0 */ 2919 length_code = is_undefined ? STATE_UNDF : STATE_BYTE; 2920 if (opcode_as_number & VIT_OPCODE_SPECIAL) 2921 { 2922 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) 2923 { 2924 /* br or jsb */ 2925 frag_var (rs_machine_dependent, 5, 1, 2926 ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code), 2927 this_add_symbol, this_add_number, 2928 opcode_low_byteP); 2929 } 2930 else 2931 { 2932 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) 2933 { 2934 length_code = STATE_WORD; 2935 /* JF: There is no state_byte for this one! */ 2936 frag_var (rs_machine_dependent, 10, 2, 2937 ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code), 2938 this_add_symbol, this_add_number, 2939 opcode_low_byteP); 2940 } 2941 else 2942 { 2943 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP); 2944 frag_var (rs_machine_dependent, 9, 1, 2945 ENCODE_RELAX (STATE_COMPLEX_HOP, length_code), 2946 this_add_symbol, this_add_number, 2947 opcode_low_byteP); 2948 } 2949 } 2950 } 2951 else 2952 { 2953 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP); 2954 frag_var (rs_machine_dependent, 7, 1, 2955 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code), 2956 this_add_symbol, this_add_number, 2957 opcode_low_byteP); 2958 } 2959 } 2960 } 2961 else 2962 { 2963 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */ 2964 /* --- SEG FLOAT MAY APPEAR HERE --- */ 2965 if (is_absolute) 2966 { 2967 if (nbytes) 2968 { 2969 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC)); 2970 p = frag_more (nbytes); 2971 /* Conventional relocation. */ 2972 fix_new (frag_now, p - frag_now->fr_literal, nbytes, 2973 section_symbol (absolute_section), 2974 this_add_number, 1, NO_RELOC); 2975 } 2976 else 2977 { 2978 know (opcode_as_number & VIT_OPCODE_SYNTHETIC); 2979 if (opcode_as_number & VIT_OPCODE_SPECIAL) 2980 { 2981 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) 2982 { 2983 /* br or jsb */ 2984 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG; 2985 know (opcode_as_chars[1] == 0); 2986 p = frag_more (5); 2987 p[0] = VAX_ABSOLUTE_MODE; /* @#... */ 2988 md_number_to_chars (p + 1, this_add_number, 4); 2989 /* Now (eg) JMP @#foo or JSB @#foo. */ 2990 } 2991 else 2992 { 2993 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) 2994 { 2995 p = frag_more (10); 2996 p[0] = 2; 2997 p[1] = 0; 2998 p[2] = VAX_BRB; 2999 p[3] = 6; 3000 p[4] = VAX_JMP; 3001 p[5] = VAX_ABSOLUTE_MODE; /* @#... */ 3002 md_number_to_chars (p + 6, this_add_number, 4); 3003 /* Now (eg) ACBx 1f 3004 BRB 2f 3005 1: JMP @#foo 3006 2: */ 3007 } 3008 else 3009 { 3010 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP); 3011 p = frag_more (9); 3012 p[0] = 2; 3013 p[1] = VAX_BRB; 3014 p[2] = 6; 3015 p[3] = VAX_JMP; 3016 p[4] = VAX_ABSOLUTE_MODE; /* @#... */ 3017 md_number_to_chars (p + 5, this_add_number, 4); 3018 /* Now (eg) xOBxxx 1f 3019 BRB 2f 3020 1: JMP @#foo 3021 2: */ 3022 } 3023 } 3024 } 3025 else 3026 { 3027 /* b<cond> */ 3028 *opcode_low_byteP ^= 1; 3029 /* To reverse the condition in a VAX branch, 3030 complement the lowest order bit. */ 3031 p = frag_more (7); 3032 p[0] = 6; 3033 p[1] = VAX_JMP; 3034 p[2] = VAX_ABSOLUTE_MODE; /* @#... */ 3035 md_number_to_chars (p + 3, this_add_number, 4); 3036 /* Now (eg) BLEQ 1f 3037 JMP @#foo 3038 1: */ 3039 } 3040 } 3041 } 3042 else 3043 { 3044 /* to_seg != now_seg && !is_undefinfed && !is_absolute */ 3045 if (nbytes > 0) 3046 { 3047 /* Pc-relative. Conventional relocation. */ 3048 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC)); 3049 p = frag_more (nbytes); 3050 fix_new (frag_now, p - frag_now->fr_literal, nbytes, 3051 section_symbol (absolute_section), 3052 this_add_number, 1, NO_RELOC); 3053 } 3054 else 3055 { 3056 know (opcode_as_number & VIT_OPCODE_SYNTHETIC); 3057 if (opcode_as_number & VIT_OPCODE_SPECIAL) 3058 { 3059 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) 3060 { 3061 /* br or jsb */ 3062 know (opcode_as_chars[1] == 0); 3063 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG; 3064 p = frag_more (5); 3065 p[0] = VAX_PC_RELATIVE_MODE; 3066 fix_new (frag_now, 3067 p + 1 - frag_now->fr_literal, 4, 3068 this_add_symbol, 3069 this_add_number, 1, NO_RELOC); 3070 /* Now eg JMP foo or JSB foo. */ 3071 } 3072 else 3073 { 3074 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) 3075 { 3076 p = frag_more (10); 3077 p[0] = 0; 3078 p[1] = 2; 3079 p[2] = VAX_BRB; 3080 p[3] = 6; 3081 p[4] = VAX_JMP; 3082 p[5] = VAX_PC_RELATIVE_MODE; 3083 fix_new (frag_now, 3084 p + 6 - frag_now->fr_literal, 4, 3085 this_add_symbol, 3086 this_add_number, 1, NO_RELOC); 3087 /* Now (eg) ACBx 1f 3088 BRB 2f 3089 1: JMP foo 3090 2: */ 3091 } 3092 else 3093 { 3094 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP); 3095 p = frag_more (10); 3096 p[0] = 2; 3097 p[1] = VAX_BRB; 3098 p[2] = 6; 3099 p[3] = VAX_JMP; 3100 p[4] = VAX_PC_RELATIVE_MODE; 3101 fix_new (frag_now, 3102 p + 5 - frag_now->fr_literal, 3103 4, this_add_symbol, 3104 this_add_number, 1, NO_RELOC); 3105 /* Now (eg) xOBxxx 1f 3106 BRB 2f 3107 1: JMP foo 3108 2: */ 3109 } 3110 } 3111 } 3112 else 3113 { 3114 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP); 3115 *opcode_low_byteP ^= 1; /* Reverse branch condition. */ 3116 p = frag_more (7); 3117 p[0] = 6; 3118 p[1] = VAX_JMP; 3119 p[2] = VAX_PC_RELATIVE_MODE; 3120 fix_new (frag_now, p + 3 - frag_now->fr_literal, 3121 4, this_add_symbol, 3122 this_add_number, 1, NO_RELOC); 3123 } 3124 } 3125 } 3126 } 3127 } 3128 else 3129 { 3130 /* So it is ordinary operand. */ 3131 know (operandP->vop_access != 'b'); 3132 /* ' ' target-independent: elsewhere. */ 3133 know (operandP->vop_access != ' '); 3134 know (operandP->vop_access == 'a' 3135 || operandP->vop_access == 'm' 3136 || operandP->vop_access == 'r' 3137 || operandP->vop_access == 'v' 3138 || operandP->vop_access == 'w'); 3139 if (operandP->vop_short == 's') 3140 { 3141 if (is_absolute) 3142 { 3143 if (this_add_number >= 64) 3144 { 3145 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."), 3146 (long) this_add_number); 3147 operandP->vop_short = 'i'; 3148 operandP->vop_mode = 8; 3149 operandP->vop_reg = 0xF; 3150 } 3151 } 3152 else 3153 { 3154 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"), 3155 segment_name (now_seg), segment_name (to_seg)); 3156 operandP->vop_short = 'i'; 3157 operandP->vop_mode = 8; 3158 operandP->vop_reg = 0xF; 3159 } 3160 } 3161 if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8 3162 || (operandP->vop_reg != 0xF && operandP->vop_mode < 10))) 3163 { 3164 /* One byte operand. */ 3165 know (operandP->vop_mode > 3); 3166 FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg); 3167 /* All 1-bytes except S^# happen here. */ 3168 } 3169 else 3170 { 3171 /* {@}{q^}foo{(Rn)} or S^#foo */ 3172 if (operandP->vop_reg == -1 && operandP->vop_short != 's') 3173 { 3174 /* "{@}{q^}foo" */ 3175 if (to_seg == now_seg) 3176 { 3177 if (length == 0) 3178 { 3179 know (operandP->vop_short == ' '); 3180 length_code = STATE_BYTE; 3181 #ifdef OBJ_ELF 3182 if (S_IS_EXTERNAL (this_add_symbol) 3183 || S_IS_WEAK (this_add_symbol)) 3184 length_code = STATE_UNDF; 3185 #endif 3186 p = frag_var (rs_machine_dependent, 10, 2, 3187 ENCODE_RELAX (STATE_PC_RELATIVE, length_code), 3188 this_add_symbol, this_add_number, 3189 opcode_low_byteP); 3190 know (operandP->vop_mode == 10 + at); 3191 *p = at << 4; 3192 /* At is the only context we need to carry 3193 to other side of relax() process. Must 3194 be in the correct bit position of VAX 3195 operand spec. byte. */ 3196 } 3197 else 3198 { 3199 know (length); 3200 know (operandP->vop_short != ' '); 3201 p = frag_more (length + 1); 3202 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4); 3203 fix_new (frag_now, p + 1 - frag_now->fr_literal, 3204 length, this_add_symbol, 3205 this_add_number, 1, NO_RELOC); 3206 } 3207 } 3208 else 3209 { 3210 /* to_seg != now_seg */ 3211 if (this_add_symbol == NULL) 3212 { 3213 know (is_absolute); 3214 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */ 3215 p = frag_more (5); 3216 p[0] = VAX_ABSOLUTE_MODE; /* @#... */ 3217 md_number_to_chars (p + 1, this_add_number, 4); 3218 if (length && length != 4) 3219 as_warn (_("Length specification ignored. Address mode 9F used")); 3220 } 3221 else 3222 { 3223 /* {@}{q^}other_seg */ 3224 know ((length == 0 && operandP->vop_short == ' ') 3225 || (length > 0 && operandP->vop_short != ' ')); 3226 if (is_undefined 3227 #ifdef OBJ_ELF 3228 || S_IS_WEAK(this_add_symbol) 3229 || S_IS_EXTERNAL(this_add_symbol) 3230 #endif 3231 ) 3232 { 3233 switch (length) 3234 { 3235 default: length_code = STATE_UNDF; break; 3236 case 1: length_code = STATE_BYTE; break; 3237 case 2: length_code = STATE_WORD; break; 3238 case 4: length_code = STATE_LONG; break; 3239 } 3240 /* We have a SEG_UNKNOWN symbol. It might 3241 turn out to be in the same segment as 3242 the instruction, permitting relaxation. */ 3243 p = frag_var (rs_machine_dependent, 5, 2, 3244 ENCODE_RELAX (STATE_PC_RELATIVE, length_code), 3245 this_add_symbol, this_add_number, 3246 opcode_low_byteP); 3247 p[0] = at << 4; 3248 } 3249 else 3250 { 3251 if (length == 0) 3252 { 3253 know (operandP->vop_short == ' '); 3254 length = 4; /* Longest possible. */ 3255 } 3256 p = frag_more (length + 1); 3257 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4); 3258 md_number_to_chars (p + 1, this_add_number, length); 3259 fix_new (frag_now, 3260 p + 1 - frag_now->fr_literal, 3261 length, this_add_symbol, 3262 this_add_number, 1, NO_RELOC); 3263 } 3264 } 3265 } 3266 } 3267 else 3268 { 3269 /* {@}{q^}foo(Rn) or S^# or I^# or # */ 3270 if (operandP->vop_mode < 0xA) 3271 { 3272 /* # or S^# or I^# */ 3273 if (operandP->vop_access == 'v' 3274 || operandP->vop_access == 'a') 3275 { 3276 if (operandP->vop_access == 'v') 3277 as_warn (_("Invalid operand: immediate value used as base address.")); 3278 else 3279 as_warn (_("Invalid operand: immediate value used as address.")); 3280 /* gcc 2.6.3 is known to generate these in at least 3281 one case. */ 3282 } 3283 if (length == 0 3284 && is_absolute && (expP->X_op != O_big) 3285 && operandP->vop_mode == 8 /* No '@'. */ 3286 && this_add_number < 64) 3287 { 3288 operandP->vop_short = 's'; 3289 } 3290 if (operandP->vop_short == 's') 3291 { 3292 FRAG_APPEND_1_CHAR (this_add_number); 3293 } 3294 else 3295 { 3296 /* I^#... */ 3297 know (nbytes); 3298 p = frag_more (nbytes + 1); 3299 know (operandP->vop_reg == 0xF); 3300 #ifdef OBJ_ELF 3301 if (flag_want_pic && operandP->vop_mode == 8 3302 && this_add_symbol != NULL) 3303 { 3304 as_warn (_("Symbol '%s' used as immediate operand in PIC mode."), 3305 S_GET_NAME (this_add_symbol)); 3306 } 3307 #endif 3308 p[0] = (operandP->vop_mode << 4) | 0xF; 3309 if ((is_absolute) && (expP->X_op != O_big)) 3310 { 3311 /* If nbytes > 4, then we are scrod. We 3312 don't know if the high order bytes 3313 are to be 0xFF or 0x00. BSD4.2 & RMS 3314 say use 0x00. OK --- but this 3315 assembler needs ANOTHER rewrite to 3316 cope properly with this bug. */ 3317 md_number_to_chars (p + 1, this_add_number, 3318 min (sizeof (valueT), 3319 (size_t) nbytes)); 3320 if ((size_t) nbytes > sizeof (valueT)) 3321 memset (p + 1 + sizeof (valueT), 3322 '\0', nbytes - sizeof (valueT)); 3323 } 3324 else 3325 { 3326 if (expP->X_op == O_big) 3327 { 3328 /* Problem here is to get the bytes 3329 in the right order. We stored 3330 our constant as LITTLENUMs, not 3331 bytes. */ 3332 LITTLENUM_TYPE *lP; 3333 3334 lP = floatP->low; 3335 if (nbytes & 1) 3336 { 3337 know (nbytes == 1); 3338 p[1] = *lP; 3339 } 3340 else 3341 { 3342 for (p++; nbytes; nbytes -= 2, p += 2, lP++) 3343 md_number_to_chars (p, *lP, 2); 3344 } 3345 } 3346 else 3347 { 3348 fix_new (frag_now, p + 1 - frag_now->fr_literal, 3349 nbytes, this_add_symbol, 3350 this_add_number, 0, NO_RELOC); 3351 } 3352 } 3353 } 3354 } 3355 else 3356 { 3357 /* {@}{q^}foo(Rn) */ 3358 know ((length == 0 && operandP->vop_short == ' ') 3359 || (length > 0 && operandP->vop_short != ' ')); 3360 if (length == 0) 3361 { 3362 if (is_absolute) 3363 { 3364 long test; 3365 3366 test = this_add_number; 3367 3368 if (test < 0) 3369 test = ~test; 3370 3371 length = test & 0xffff8000 ? 4 3372 : test & 0xffffff80 ? 2 3373 : 1; 3374 } 3375 else 3376 { 3377 length = 4; 3378 } 3379 } 3380 #ifdef OBJ_ELF 3381 if (flag_want_pic && this_add_symbol != NULL) 3382 { 3383 as_warn (_("Symbol '%s' used as displacement in PIC mode."), 3384 S_GET_NAME (this_add_symbol)); 3385 } 3386 #endif 3387 p = frag_more (1 + length); 3388 know (operandP->vop_reg != 0xf); 3389 know (operandP->vop_reg >= 0); 3390 p[0] = operandP->vop_reg 3391 | ((at | "?\12\14?\16"[length]) << 4); 3392 if (is_absolute) 3393 { 3394 md_number_to_chars (p + 1, this_add_number, length); 3395 } 3396 else 3397 { 3398 fix_new (frag_now, p + 1 - frag_now->fr_literal, 3399 length, this_add_symbol, 3400 this_add_number, 0, NO_RELOC); 3401 } 3402 } 3403 } 3404 } 3405 } 3406 } 3407 } 3408 3409 void 3410 md_begin (void) 3411 { 3412 const char *errtxt; 3413 FLONUM_TYPE *fP; 3414 int i; 3415 3416 if ((errtxt = vip_begin (1, "$", "*", "`")) != 0) 3417 as_fatal (_("VIP_BEGIN error:%s"), errtxt); 3418 3419 for (i = 0, fP = float_operand; 3420 fP < float_operand + VIT_MAX_OPERANDS; 3421 i++, fP++) 3422 { 3423 fP->low = &big_operand_bits[i][0]; 3424 fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1]; 3425 } 3426 } 3427 3428 static char *vax_cons_special_reloc; 3429 3430 void 3431 vax_cons (expressionS *exp, int size) 3432 { 3433 char *save; 3434 3435 SKIP_WHITESPACE (); 3436 vax_cons_special_reloc = NULL; 3437 save = input_line_pointer; 3438 if (input_line_pointer[0] == '%') 3439 { 3440 if (strncmp (input_line_pointer + 1, "pcrel", 5) == 0) 3441 { 3442 input_line_pointer += 6; 3443 vax_cons_special_reloc = "pcrel"; 3444 } 3445 if (vax_cons_special_reloc) 3446 { 3447 int bad = 0; 3448 3449 switch (size) 3450 { 3451 case 1: 3452 if (*input_line_pointer != '8') 3453 bad = 1; 3454 input_line_pointer--; 3455 break; 3456 case 2: 3457 if (input_line_pointer[0] != '1' || input_line_pointer[1] != '6') 3458 bad = 1; 3459 break; 3460 case 4: 3461 if (input_line_pointer[0] != '3' || input_line_pointer[1] != '2') 3462 bad = 1; 3463 break; 3464 default: 3465 bad = 1; 3466 break; 3467 } 3468 3469 if (bad) 3470 { 3471 as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"), 3472 vax_cons_special_reloc, size * 8, size); 3473 } 3474 else 3475 { 3476 input_line_pointer += 2; 3477 if (*input_line_pointer != '(') 3478 { 3479 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"), 3480 vax_cons_special_reloc, size * 8); 3481 bad = 1; 3482 } 3483 } 3484 3485 if (bad) 3486 { 3487 input_line_pointer = save; 3488 vax_cons_special_reloc = NULL; 3489 } 3490 else 3491 { 3492 int c; 3493 char *end = ++input_line_pointer; 3494 int npar = 0; 3495 3496 while (! is_end_of_line[(c = *end)]) 3497 { 3498 if (c == '(') 3499 npar++; 3500 else if (c == ')') 3501 { 3502 if (!npar) 3503 break; 3504 npar--; 3505 } 3506 end++; 3507 } 3508 3509 if (c != ')') 3510 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"), 3511 vax_cons_special_reloc, size * 8); 3512 else 3513 { 3514 *end = '\0'; 3515 expression (exp); 3516 *end = c; 3517 if (input_line_pointer != end) 3518 { 3519 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"), 3520 vax_cons_special_reloc, size * 8); 3521 } 3522 else 3523 { 3524 input_line_pointer++; 3525 SKIP_WHITESPACE (); 3526 c = *input_line_pointer; 3527 if (! is_end_of_line[c] && c != ',') 3528 as_bad (_("Illegal operands: garbage after %%r_%s%d()"), 3529 vax_cons_special_reloc, size * 8); 3530 } 3531 } 3532 } 3533 } 3534 } 3535 if (vax_cons_special_reloc == NULL) 3536 expression (exp); 3537 } 3538 3539 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a 3540 reloc for a cons. */ 3541 3542 void 3543 vax_cons_fix_new (fragS *frag, int where, unsigned int nbytes, expressionS *exp) 3544 { 3545 bfd_reloc_code_real_type r; 3546 3547 r = (nbytes == 1 ? BFD_RELOC_8 : 3548 (nbytes == 2 ? BFD_RELOC_16 : BFD_RELOC_32)); 3549 3550 if (vax_cons_special_reloc) 3551 { 3552 if (*vax_cons_special_reloc == 'p') 3553 { 3554 switch (nbytes) 3555 { 3556 case 1: r = BFD_RELOC_8_PCREL; break; 3557 case 2: r = BFD_RELOC_16_PCREL; break; 3558 case 4: r = BFD_RELOC_32_PCREL; break; 3559 default: abort (); 3560 } 3561 } 3562 } 3563 3564 fix_new_exp (frag, where, (int) nbytes, exp, 0, r); 3565 vax_cons_special_reloc = NULL; 3566 } 3567 3568 char * 3569 md_atof (int type, char * litP, int * sizeP) 3570 { 3571 return vax_md_atof (type, litP, sizeP); 3572 } 3573