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