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