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