1 /* 2 * Integer number functions. 3 * 4 * Copyright (C) 2001-2007 Peter Johnson 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS'' 16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE 19 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 * POSSIBILITY OF SUCH DAMAGE. 26 */ 27 #include "util.h" 28 29 #include <ctype.h> 30 #include <limits.h> 31 32 #include "coretype.h" 33 #include "bitvect.h" 34 #include "file.h" 35 36 #include "errwarn.h" 37 #include "intnum.h" 38 39 40 /* "Native" "word" size for intnum calculations. */ 41 #define BITVECT_NATIVE_SIZE 256 42 43 struct yasm_intnum { 44 union val { 45 long l; /* integer value (for integers <32 bits) */ 46 wordptr bv; /* bit vector (for integers >=32 bits) */ 47 } val; 48 enum { INTNUM_L, INTNUM_BV } type; 49 }; 50 51 /* static bitvect used for conversions */ 52 static /*@only@*/ wordptr conv_bv; 53 54 /* static bitvects used for computation */ 55 static /*@only@*/ wordptr result, spare, op1static, op2static; 56 57 static /*@only@*/ BitVector_from_Dec_static_data *from_dec_data; 58 59 60 void 61 yasm_intnum_initialize(void) 62 { 63 conv_bv = BitVector_Create(BITVECT_NATIVE_SIZE, FALSE); 64 result = BitVector_Create(BITVECT_NATIVE_SIZE, FALSE); 65 spare = BitVector_Create(BITVECT_NATIVE_SIZE, FALSE); 66 op1static = BitVector_Create(BITVECT_NATIVE_SIZE, FALSE); 67 op2static = BitVector_Create(BITVECT_NATIVE_SIZE, FALSE); 68 from_dec_data = BitVector_from_Dec_static_Boot(BITVECT_NATIVE_SIZE); 69 } 70 71 void 72 yasm_intnum_cleanup(void) 73 { 74 BitVector_from_Dec_static_Shutdown(from_dec_data); 75 BitVector_Destroy(op2static); 76 BitVector_Destroy(op1static); 77 BitVector_Destroy(spare); 78 BitVector_Destroy(result); 79 BitVector_Destroy(conv_bv); 80 } 81 82 /* Compress a bitvector into intnum storage. 83 * If saved as a bitvector, clones the passed bitvector. 84 * Can modify the passed bitvector. 85 */ 86 static void 87 intnum_frombv(/*@out@*/ yasm_intnum *intn, wordptr bv) 88 { 89 if (Set_Max(bv) < 31) { 90 intn->type = INTNUM_L; 91 intn->val.l = (long)BitVector_Chunk_Read(bv, 31, 0); 92 } else if (BitVector_msb_(bv)) { 93 /* Negative, negate and see if we'll fit into a long. */ 94 unsigned long ul; 95 BitVector_Negate(bv, bv); 96 if (Set_Max(bv) >= 32 || 97 ((ul = BitVector_Chunk_Read(bv, 32, 0)) & 0x80000000)) { 98 /* too negative */ 99 BitVector_Negate(bv, bv); 100 intn->type = INTNUM_BV; 101 intn->val.bv = BitVector_Clone(bv); 102 } else { 103 intn->type = INTNUM_L; 104 intn->val.l = -((long)ul); 105 } 106 } else { 107 intn->type = INTNUM_BV; 108 intn->val.bv = BitVector_Clone(bv); 109 } 110 } 111 112 /* If intnum is a BV, returns its bitvector directly. 113 * If not, converts into passed bv and returns that instead. 114 */ 115 static wordptr 116 intnum_tobv(/*@returned@*/ wordptr bv, const yasm_intnum *intn) 117 { 118 if (intn->type == INTNUM_BV) 119 return intn->val.bv; 120 121 BitVector_Empty(bv); 122 if (intn->val.l >= 0) 123 BitVector_Chunk_Store(bv, 32, 0, (unsigned long)intn->val.l); 124 else { 125 BitVector_Chunk_Store(bv, 32, 0, (unsigned long)-intn->val.l); 126 BitVector_Negate(bv, bv); 127 } 128 return bv; 129 } 130 131 yasm_intnum * 132 yasm_intnum_create_dec(char *str) 133 { 134 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 135 136 switch (BitVector_from_Dec_static(from_dec_data, conv_bv, 137 (unsigned char *)str)) { 138 case ErrCode_Pars: 139 yasm_error_set(YASM_ERROR_VALUE, N_("invalid decimal literal")); 140 break; 141 case ErrCode_Ovfl: 142 yasm_error_set(YASM_ERROR_OVERFLOW, 143 N_("Numeric constant too large for internal format")); 144 break; 145 default: 146 break; 147 } 148 intnum_frombv(intn, conv_bv); 149 return intn; 150 } 151 152 yasm_intnum * 153 yasm_intnum_create_bin(char *str) 154 { 155 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 156 157 switch (BitVector_from_Bin(conv_bv, (unsigned char *)str)) { 158 case ErrCode_Pars: 159 yasm_error_set(YASM_ERROR_VALUE, N_("invalid binary literal")); 160 break; 161 case ErrCode_Ovfl: 162 yasm_error_set(YASM_ERROR_OVERFLOW, 163 N_("Numeric constant too large for internal format")); 164 break; 165 default: 166 break; 167 } 168 intnum_frombv(intn, conv_bv); 169 return intn; 170 } 171 172 yasm_intnum * 173 yasm_intnum_create_oct(char *str) 174 { 175 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 176 177 switch (BitVector_from_Oct(conv_bv, (unsigned char *)str)) { 178 case ErrCode_Pars: 179 yasm_error_set(YASM_ERROR_VALUE, N_("invalid octal literal")); 180 break; 181 case ErrCode_Ovfl: 182 yasm_error_set(YASM_ERROR_OVERFLOW, 183 N_("Numeric constant too large for internal format")); 184 break; 185 default: 186 break; 187 } 188 intnum_frombv(intn, conv_bv); 189 return intn; 190 } 191 192 yasm_intnum * 193 yasm_intnum_create_hex(char *str) 194 { 195 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 196 197 switch (BitVector_from_Hex(conv_bv, (unsigned char *)str)) { 198 case ErrCode_Pars: 199 yasm_error_set(YASM_ERROR_VALUE, N_("invalid hex literal")); 200 break; 201 case ErrCode_Ovfl: 202 yasm_error_set(YASM_ERROR_OVERFLOW, 203 N_("Numeric constant too large for internal format")); 204 break; 205 default: 206 break; 207 } 208 intnum_frombv(intn, conv_bv); 209 return intn; 210 } 211 212 /*@-usedef -compdef -uniondef@*/ 213 yasm_intnum * 214 yasm_intnum_create_charconst_nasm(const char *str) 215 { 216 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 217 size_t len = strlen(str); 218 219 if(len*8 > BITVECT_NATIVE_SIZE) 220 yasm_error_set(YASM_ERROR_OVERFLOW, 221 N_("Character constant too large for internal format")); 222 223 /* be conservative in choosing bitvect in case MSB is set */ 224 if (len > 3) { 225 BitVector_Empty(conv_bv); 226 intn->type = INTNUM_BV; 227 } else { 228 intn->val.l = 0; 229 intn->type = INTNUM_L; 230 } 231 232 switch (len) { 233 case 3: 234 intn->val.l |= ((unsigned long)str[2]) & 0xff; 235 intn->val.l <<= 8; 236 /*@fallthrough@*/ 237 case 2: 238 intn->val.l |= ((unsigned long)str[1]) & 0xff; 239 intn->val.l <<= 8; 240 /*@fallthrough@*/ 241 case 1: 242 intn->val.l |= ((unsigned long)str[0]) & 0xff; 243 case 0: 244 break; 245 default: 246 /* >=32 bit conversion */ 247 while (len) { 248 BitVector_Move_Left(conv_bv, 8); 249 BitVector_Chunk_Store(conv_bv, 8, 0, 250 ((unsigned long)str[--len]) & 0xff); 251 } 252 intn->val.bv = BitVector_Clone(conv_bv); 253 } 254 255 return intn; 256 } 257 258 yasm_intnum * 259 yasm_intnum_create_charconst_tasm(const char *str) 260 { 261 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 262 size_t len = strlen(str); 263 size_t i; 264 265 if(len*8 > BITVECT_NATIVE_SIZE) 266 yasm_error_set(YASM_ERROR_OVERFLOW, 267 N_("Character constant too large for internal format")); 268 269 /* be conservative in choosing bitvect in case MSB is set */ 270 if (len > 3) { 271 BitVector_Empty(conv_bv); 272 intn->type = INTNUM_BV; 273 } else { 274 intn->val.l = 0; 275 intn->type = INTNUM_L; 276 } 277 278 /* tasm uses big endian notation */ 279 i = 0; 280 switch (len) { 281 case 3: 282 intn->val.l |= ((unsigned long)str[i++]) & 0xff; 283 intn->val.l <<= 8; 284 /*@fallthrough@*/ 285 case 2: 286 intn->val.l |= ((unsigned long)str[i++]) & 0xff; 287 intn->val.l <<= 8; 288 /*@fallthrough@*/ 289 case 1: 290 intn->val.l |= ((unsigned long)str[i++]) & 0xff; 291 case 0: 292 break; 293 default: 294 /* >=32 bit conversion */ 295 while (i < len) { 296 BitVector_Chunk_Store(conv_bv, 8, (len-i-1)*8, 297 ((unsigned long)str[i]) & 0xff); 298 i++; 299 } 300 intn->val.bv = BitVector_Clone(conv_bv); 301 } 302 303 return intn; 304 } 305 /*@=usedef =compdef =uniondef@*/ 306 307 yasm_intnum * 308 yasm_intnum_create_uint(unsigned long i) 309 { 310 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 311 312 if (i > LONG_MAX) { 313 /* Too big, store as bitvector */ 314 intn->val.bv = BitVector_Create(BITVECT_NATIVE_SIZE, TRUE); 315 intn->type = INTNUM_BV; 316 BitVector_Chunk_Store(intn->val.bv, 32, 0, i); 317 } else { 318 intn->val.l = (long)i; 319 intn->type = INTNUM_L; 320 } 321 322 return intn; 323 } 324 325 yasm_intnum * 326 yasm_intnum_create_int(long i) 327 { 328 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 329 330 intn->val.l = i; 331 intn->type = INTNUM_L; 332 333 return intn; 334 } 335 336 yasm_intnum * 337 yasm_intnum_create_leb128(const unsigned char *ptr, int sign, 338 unsigned long *size) 339 { 340 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 341 const unsigned char *ptr_orig = ptr; 342 unsigned long i = 0; 343 344 BitVector_Empty(conv_bv); 345 for (;;) { 346 BitVector_Chunk_Store(conv_bv, 7, i, *ptr); 347 i += 7; 348 if ((*ptr & 0x80) != 0x80) 349 break; 350 ptr++; 351 } 352 353 *size = (unsigned long)(ptr-ptr_orig)+1; 354 355 if(i > BITVECT_NATIVE_SIZE) 356 yasm_error_set(YASM_ERROR_OVERFLOW, 357 N_("Numeric constant too large for internal format")); 358 else if (sign && (*ptr & 0x40) == 0x40) 359 BitVector_Interval_Fill(conv_bv, i, BITVECT_NATIVE_SIZE-1); 360 361 intnum_frombv(intn, conv_bv); 362 return intn; 363 } 364 365 yasm_intnum * 366 yasm_intnum_create_sized(unsigned char *ptr, int sign, size_t srcsize, 367 int bigendian) 368 { 369 yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum)); 370 unsigned long i = 0; 371 372 if (srcsize*8 > BITVECT_NATIVE_SIZE) 373 yasm_error_set(YASM_ERROR_OVERFLOW, 374 N_("Numeric constant too large for internal format")); 375 376 /* Read the buffer into a bitvect */ 377 BitVector_Empty(conv_bv); 378 if (bigendian) { 379 /* TODO */ 380 yasm_internal_error(N_("big endian not implemented")); 381 } else { 382 for (i = 0; i < srcsize; i++) 383 BitVector_Chunk_Store(conv_bv, 8, i*8, ptr[i]); 384 } 385 386 /* Sign extend if needed */ 387 if (srcsize*8 < BITVECT_NATIVE_SIZE && sign && (ptr[i-1] & 0x80) == 0x80) 388 BitVector_Interval_Fill(conv_bv, i*8, BITVECT_NATIVE_SIZE-1); 389 390 intnum_frombv(intn, conv_bv); 391 return intn; 392 } 393 394 yasm_intnum * 395 yasm_intnum_copy(const yasm_intnum *intn) 396 { 397 yasm_intnum *n = yasm_xmalloc(sizeof(yasm_intnum)); 398 399 switch (intn->type) { 400 case INTNUM_L: 401 n->val.l = intn->val.l; 402 break; 403 case INTNUM_BV: 404 n->val.bv = BitVector_Clone(intn->val.bv); 405 break; 406 } 407 n->type = intn->type; 408 409 return n; 410 } 411 412 void 413 yasm_intnum_destroy(yasm_intnum *intn) 414 { 415 if (intn->type == INTNUM_BV) 416 BitVector_Destroy(intn->val.bv); 417 yasm_xfree(intn); 418 } 419 420 /*@-nullderef -nullpass -branchstate@*/ 421 int 422 yasm_intnum_calc(yasm_intnum *acc, yasm_expr_op op, yasm_intnum *operand) 423 { 424 boolean carry = 0; 425 wordptr op1, op2 = NULL; 426 N_int count; 427 428 /* Always do computations with in full bit vector. 429 * Bit vector results must be calculated through intermediate storage. 430 */ 431 op1 = intnum_tobv(op1static, acc); 432 if (operand) 433 op2 = intnum_tobv(op2static, operand); 434 435 if (!operand && op != YASM_EXPR_NEG && op != YASM_EXPR_NOT && 436 op != YASM_EXPR_LNOT) { 437 yasm_error_set(YASM_ERROR_ARITHMETIC, 438 N_("operation needs an operand")); 439 BitVector_Empty(result); 440 return 1; 441 } 442 443 /* A operation does a bitvector computation if result is allocated. */ 444 switch (op) { 445 case YASM_EXPR_ADD: 446 BitVector_add(result, op1, op2, &carry); 447 break; 448 case YASM_EXPR_SUB: 449 BitVector_sub(result, op1, op2, &carry); 450 break; 451 case YASM_EXPR_MUL: 452 BitVector_Multiply(result, op1, op2); 453 break; 454 case YASM_EXPR_DIV: 455 /* TODO: make sure op1 and op2 are unsigned */ 456 if (BitVector_is_empty(op2)) { 457 yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero")); 458 BitVector_Empty(result); 459 return 1; 460 } else 461 BitVector_Divide(result, op1, op2, spare); 462 break; 463 case YASM_EXPR_SIGNDIV: 464 if (BitVector_is_empty(op2)) { 465 yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero")); 466 BitVector_Empty(result); 467 return 1; 468 } else 469 BitVector_Divide(result, op1, op2, spare); 470 break; 471 case YASM_EXPR_MOD: 472 /* TODO: make sure op1 and op2 are unsigned */ 473 if (BitVector_is_empty(op2)) { 474 yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero")); 475 BitVector_Empty(result); 476 return 1; 477 } else 478 BitVector_Divide(spare, op1, op2, result); 479 break; 480 case YASM_EXPR_SIGNMOD: 481 if (BitVector_is_empty(op2)) { 482 yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero")); 483 BitVector_Empty(result); 484 return 1; 485 } else 486 BitVector_Divide(spare, op1, op2, result); 487 break; 488 case YASM_EXPR_NEG: 489 BitVector_Negate(result, op1); 490 break; 491 case YASM_EXPR_NOT: 492 Set_Complement(result, op1); 493 break; 494 case YASM_EXPR_OR: 495 Set_Union(result, op1, op2); 496 break; 497 case YASM_EXPR_AND: 498 Set_Intersection(result, op1, op2); 499 break; 500 case YASM_EXPR_XOR: 501 Set_ExclusiveOr(result, op1, op2); 502 break; 503 case YASM_EXPR_XNOR: 504 Set_ExclusiveOr(result, op1, op2); 505 Set_Complement(result, result); 506 break; 507 case YASM_EXPR_NOR: 508 Set_Union(result, op1, op2); 509 Set_Complement(result, result); 510 break; 511 case YASM_EXPR_SHL: 512 if (operand->type == INTNUM_L && operand->val.l >= 0) { 513 BitVector_Copy(result, op1); 514 BitVector_Move_Left(result, (N_int)operand->val.l); 515 } else /* don't even bother, just zero result */ 516 BitVector_Empty(result); 517 break; 518 case YASM_EXPR_SHR: 519 if (operand->type == INTNUM_L && operand->val.l >= 0) { 520 BitVector_Copy(result, op1); 521 carry = BitVector_msb_(op1); 522 count = (N_int)operand->val.l; 523 while (count-- > 0) 524 BitVector_shift_right(result, carry); 525 } else /* don't even bother, just zero result */ 526 BitVector_Empty(result); 527 break; 528 case YASM_EXPR_LOR: 529 BitVector_Empty(result); 530 BitVector_LSB(result, !BitVector_is_empty(op1) || 531 !BitVector_is_empty(op2)); 532 break; 533 case YASM_EXPR_LAND: 534 BitVector_Empty(result); 535 BitVector_LSB(result, !BitVector_is_empty(op1) && 536 !BitVector_is_empty(op2)); 537 break; 538 case YASM_EXPR_LNOT: 539 BitVector_Empty(result); 540 BitVector_LSB(result, BitVector_is_empty(op1)); 541 break; 542 case YASM_EXPR_LXOR: 543 BitVector_Empty(result); 544 BitVector_LSB(result, !BitVector_is_empty(op1) ^ 545 !BitVector_is_empty(op2)); 546 break; 547 case YASM_EXPR_LXNOR: 548 BitVector_Empty(result); 549 BitVector_LSB(result, !(!BitVector_is_empty(op1) ^ 550 !BitVector_is_empty(op2))); 551 break; 552 case YASM_EXPR_LNOR: 553 BitVector_Empty(result); 554 BitVector_LSB(result, !(!BitVector_is_empty(op1) || 555 !BitVector_is_empty(op2))); 556 break; 557 case YASM_EXPR_EQ: 558 BitVector_Empty(result); 559 BitVector_LSB(result, BitVector_equal(op1, op2)); 560 break; 561 case YASM_EXPR_LT: 562 BitVector_Empty(result); 563 BitVector_LSB(result, BitVector_Compare(op1, op2) < 0); 564 break; 565 case YASM_EXPR_GT: 566 BitVector_Empty(result); 567 BitVector_LSB(result, BitVector_Compare(op1, op2) > 0); 568 break; 569 case YASM_EXPR_LE: 570 BitVector_Empty(result); 571 BitVector_LSB(result, BitVector_Compare(op1, op2) <= 0); 572 break; 573 case YASM_EXPR_GE: 574 BitVector_Empty(result); 575 BitVector_LSB(result, BitVector_Compare(op1, op2) >= 0); 576 break; 577 case YASM_EXPR_NE: 578 BitVector_Empty(result); 579 BitVector_LSB(result, !BitVector_equal(op1, op2)); 580 break; 581 case YASM_EXPR_SEG: 582 yasm_error_set(YASM_ERROR_ARITHMETIC, N_("invalid use of '%s'"), 583 "SEG"); 584 break; 585 case YASM_EXPR_WRT: 586 yasm_error_set(YASM_ERROR_ARITHMETIC, N_("invalid use of '%s'"), 587 "WRT"); 588 break; 589 case YASM_EXPR_SEGOFF: 590 yasm_error_set(YASM_ERROR_ARITHMETIC, N_("invalid use of '%s'"), 591 ":"); 592 break; 593 case YASM_EXPR_IDENT: 594 if (result) 595 BitVector_Copy(result, op1); 596 break; 597 default: 598 yasm_error_set(YASM_ERROR_ARITHMETIC, 599 N_("invalid operation in intnum calculation")); 600 BitVector_Empty(result); 601 return 1; 602 } 603 604 /* Try to fit the result into 32 bits if possible */ 605 if (acc->type == INTNUM_BV) 606 BitVector_Destroy(acc->val.bv); 607 intnum_frombv(acc, result); 608 return 0; 609 } 610 /*@=nullderef =nullpass =branchstate@*/ 611 612 int 613 yasm_intnum_compare(const yasm_intnum *intn1, const yasm_intnum *intn2) 614 { 615 wordptr op1, op2; 616 617 if (intn1->type == INTNUM_L && intn2->type == INTNUM_L) { 618 if (intn1->val.l < intn2->val.l) 619 return -1; 620 if (intn1->val.l > intn2->val.l) 621 return 1; 622 return 0; 623 } 624 625 op1 = intnum_tobv(op1static, intn1); 626 op2 = intnum_tobv(op2static, intn2); 627 return BitVector_Compare(op1, op2); 628 } 629 630 void 631 yasm_intnum_zero(yasm_intnum *intn) 632 { 633 yasm_intnum_set_int(intn, 0); 634 } 635 636 void 637 yasm_intnum_set(yasm_intnum *intn, const yasm_intnum *val) 638 { 639 if (intn->type == val->type) { 640 switch (val->type) { 641 case INTNUM_L: 642 intn->val.l = val->val.l; 643 break; 644 case INTNUM_BV: 645 BitVector_Copy(intn->val.bv, val->val.bv); 646 break; 647 } 648 } else { 649 switch (val->type) { 650 case INTNUM_L: 651 BitVector_Destroy(intn->val.bv); 652 intn->val.l = val->val.l; 653 break; 654 case INTNUM_BV: 655 intn->val.bv = BitVector_Clone(val->val.bv); 656 break; 657 } 658 intn->type = val->type; 659 } 660 } 661 662 void 663 yasm_intnum_set_uint(yasm_intnum *intn, unsigned long val) 664 { 665 if (val > LONG_MAX) { 666 if (intn->type != INTNUM_BV) { 667 intn->val.bv = BitVector_Create(BITVECT_NATIVE_SIZE, TRUE); 668 intn->type = INTNUM_BV; 669 } 670 BitVector_Chunk_Store(intn->val.bv, 32, 0, val); 671 } else { 672 if (intn->type == INTNUM_BV) { 673 BitVector_Destroy(intn->val.bv); 674 intn->type = INTNUM_L; 675 } 676 intn->val.l = (long)val; 677 } 678 } 679 680 void 681 yasm_intnum_set_int(yasm_intnum *intn, long val) 682 { 683 if (intn->type == INTNUM_BV) 684 BitVector_Destroy(intn->val.bv); 685 intn->type = INTNUM_L; 686 intn->val.l = val; 687 } 688 689 int 690 yasm_intnum_is_zero(const yasm_intnum *intn) 691 { 692 return (intn->type == INTNUM_L && intn->val.l == 0); 693 } 694 695 int 696 yasm_intnum_is_pos1(const yasm_intnum *intn) 697 { 698 return (intn->type == INTNUM_L && intn->val.l == 1); 699 } 700 701 int 702 yasm_intnum_is_neg1(const yasm_intnum *intn) 703 { 704 return (intn->type == INTNUM_L && intn->val.l == -1); 705 } 706 707 int 708 yasm_intnum_sign(const yasm_intnum *intn) 709 { 710 if (intn->type == INTNUM_L) { 711 if (intn->val.l == 0) 712 return 0; 713 else if (intn->val.l < 0) 714 return -1; 715 else 716 return 1; 717 } else 718 return BitVector_Sign(intn->val.bv); 719 } 720 721 unsigned long 722 yasm_intnum_get_uint(const yasm_intnum *intn) 723 { 724 switch (intn->type) { 725 case INTNUM_L: 726 if (intn->val.l < 0) 727 return 0; 728 return (unsigned long)intn->val.l; 729 case INTNUM_BV: 730 if (BitVector_msb_(intn->val.bv)) 731 return 0; 732 if (Set_Max(intn->val.bv) > 32) 733 return ULONG_MAX; 734 return BitVector_Chunk_Read(intn->val.bv, 32, 0); 735 default: 736 yasm_internal_error(N_("unknown intnum type")); 737 /*@notreached@*/ 738 return 0; 739 } 740 } 741 742 long 743 yasm_intnum_get_int(const yasm_intnum *intn) 744 { 745 switch (intn->type) { 746 case INTNUM_L: 747 return intn->val.l; 748 case INTNUM_BV: 749 if (BitVector_msb_(intn->val.bv)) { 750 /* it's negative: negate the bitvector to get a positive 751 * number, then negate the positive number. 752 */ 753 unsigned long ul; 754 755 BitVector_Negate(conv_bv, intn->val.bv); 756 if (Set_Max(conv_bv) >= 32) { 757 /* too negative */ 758 return LONG_MIN; 759 } 760 ul = BitVector_Chunk_Read(conv_bv, 32, 0); 761 /* check for too negative */ 762 return (ul & 0x80000000) ? LONG_MIN : -((long)ul); 763 } 764 765 /* it's positive, and since it's a BV, it must be >0x7FFFFFFF */ 766 return LONG_MAX; 767 default: 768 yasm_internal_error(N_("unknown intnum type")); 769 /*@notreached@*/ 770 return 0; 771 } 772 } 773 774 void 775 yasm_intnum_get_sized(const yasm_intnum *intn, unsigned char *ptr, 776 size_t destsize, size_t valsize, int shift, 777 int bigendian, int warn) 778 { 779 wordptr op1 = op1static, op2; 780 unsigned char *buf; 781 unsigned int len; 782 size_t rshift = shift < 0 ? (size_t)(-shift) : 0; 783 int carry_in; 784 785 /* Currently don't support destinations larger than our native size */ 786 if (destsize*8 > BITVECT_NATIVE_SIZE) 787 yasm_internal_error(N_("destination too large")); 788 789 /* General size warnings */ 790 if (warn<0 && !yasm_intnum_check_size(intn, valsize, rshift, 1)) 791 yasm_warn_set(YASM_WARN_GENERAL, 792 N_("value does not fit in signed %d bit field"), 793 valsize); 794 if (warn>0 && !yasm_intnum_check_size(intn, valsize, rshift, 2)) 795 yasm_warn_set(YASM_WARN_GENERAL, 796 N_("value does not fit in %d bit field"), valsize); 797 798 /* Read the original data into a bitvect */ 799 if (bigendian) { 800 /* TODO */ 801 yasm_internal_error(N_("big endian not implemented")); 802 } else 803 BitVector_Block_Store(op1, ptr, (N_int)destsize); 804 805 /* If not already a bitvect, convert value to be written to a bitvect */ 806 op2 = intnum_tobv(op2static, intn); 807 808 /* Check low bits if right shifting and warnings enabled */ 809 if (warn && rshift > 0) { 810 BitVector_Copy(conv_bv, op2); 811 BitVector_Move_Left(conv_bv, (N_int)(BITVECT_NATIVE_SIZE-rshift)); 812 if (!BitVector_is_empty(conv_bv)) 813 yasm_warn_set(YASM_WARN_GENERAL, 814 N_("misaligned value, truncating to boundary")); 815 } 816 817 /* Shift right if needed */ 818 if (rshift > 0) { 819 carry_in = BitVector_msb_(op2); 820 while (rshift-- > 0) 821 BitVector_shift_right(op2, carry_in); 822 shift = 0; 823 } 824 825 /* Write the new value into the destination bitvect */ 826 BitVector_Interval_Copy(op1, op2, (unsigned int)shift, 0, (N_int)valsize); 827 828 /* Write out the new data */ 829 buf = BitVector_Block_Read(op1, &len); 830 if (bigendian) { 831 /* TODO */ 832 yasm_internal_error(N_("big endian not implemented")); 833 } else 834 memcpy(ptr, buf, destsize); 835 yasm_xfree(buf); 836 } 837 838 /* Return 1 if okay size, 0 if not */ 839 int 840 yasm_intnum_check_size(const yasm_intnum *intn, size_t size, size_t rshift, 841 int rangetype) 842 { 843 wordptr val; 844 845 /* If not already a bitvect, convert value to a bitvect */ 846 if (intn->type == INTNUM_BV) { 847 if (rshift > 0) { 848 val = conv_bv; 849 BitVector_Copy(val, intn->val.bv); 850 } else 851 val = intn->val.bv; 852 } else 853 val = intnum_tobv(conv_bv, intn); 854 855 if (size >= BITVECT_NATIVE_SIZE) 856 return 1; 857 858 if (rshift > 0) { 859 int carry_in = BitVector_msb_(val); 860 while (rshift-- > 0) 861 BitVector_shift_right(val, carry_in); 862 } 863 864 if (rangetype > 0) { 865 if (BitVector_msb_(val)) { 866 /* it's negative */ 867 int retval; 868 869 BitVector_Negate(conv_bv, val); 870 BitVector_dec(conv_bv, conv_bv); 871 retval = Set_Max(conv_bv) < (long)size-1; 872 873 return retval; 874 } 875 876 if (rangetype == 1) 877 size--; 878 } 879 return (Set_Max(val) < (long)size); 880 } 881 882 int 883 yasm_intnum_in_range(const yasm_intnum *intn, long low, long high) 884 { 885 wordptr val = intnum_tobv(result, intn); 886 wordptr lval = op1static; 887 wordptr hval = op2static; 888 889 /* Convert high and low to bitvects */ 890 BitVector_Empty(lval); 891 if (low >= 0) 892 BitVector_Chunk_Store(lval, 32, 0, (unsigned long)low); 893 else { 894 BitVector_Chunk_Store(lval, 32, 0, (unsigned long)(-low)); 895 BitVector_Negate(lval, lval); 896 } 897 898 BitVector_Empty(hval); 899 if (high >= 0) 900 BitVector_Chunk_Store(hval, 32, 0, (unsigned long)high); 901 else { 902 BitVector_Chunk_Store(hval, 32, 0, (unsigned long)(-high)); 903 BitVector_Negate(hval, hval); 904 } 905 906 /* Compare! */ 907 return (BitVector_Compare(val, lval) >= 0 908 && BitVector_Compare(val, hval) <= 0); 909 } 910 911 static unsigned long 912 get_leb128(wordptr val, unsigned char *ptr, int sign) 913 { 914 unsigned long i, size; 915 unsigned char *ptr_orig = ptr; 916 917 if (sign) { 918 /* Signed mode */ 919 if (BitVector_msb_(val)) { 920 /* Negative */ 921 BitVector_Negate(conv_bv, val); 922 size = Set_Max(conv_bv)+2; 923 } else { 924 /* Positive */ 925 size = Set_Max(val)+2; 926 } 927 } else { 928 /* Unsigned mode */ 929 size = Set_Max(val)+1; 930 } 931 932 /* Positive/Unsigned write */ 933 for (i=0; i<size; i += 7) { 934 *ptr = (unsigned char)BitVector_Chunk_Read(val, 7, i); 935 *ptr |= 0x80; 936 ptr++; 937 } 938 *(ptr-1) &= 0x7F; /* Clear MSB of last byte */ 939 return (unsigned long)(ptr-ptr_orig); 940 } 941 942 static unsigned long 943 size_leb128(wordptr val, int sign) 944 { 945 if (sign) { 946 /* Signed mode */ 947 if (BitVector_msb_(val)) { 948 /* Negative */ 949 BitVector_Negate(conv_bv, val); 950 return (Set_Max(conv_bv)+8)/7; 951 } else { 952 /* Positive */ 953 return (Set_Max(val)+8)/7; 954 } 955 } else { 956 /* Unsigned mode */ 957 return (Set_Max(val)+7)/7; 958 } 959 } 960 961 unsigned long 962 yasm_intnum_get_leb128(const yasm_intnum *intn, unsigned char *ptr, int sign) 963 { 964 wordptr val; 965 966 /* Shortcut 0 */ 967 if (intn->type == INTNUM_L && intn->val.l == 0) { 968 *ptr = 0; 969 return 1; 970 } 971 972 /* If not already a bitvect, convert value to be written to a bitvect */ 973 val = intnum_tobv(op1static, intn); 974 975 return get_leb128(val, ptr, sign); 976 } 977 978 unsigned long 979 yasm_intnum_size_leb128(const yasm_intnum *intn, int sign) 980 { 981 wordptr val; 982 983 /* Shortcut 0 */ 984 if (intn->type == INTNUM_L && intn->val.l == 0) { 985 return 1; 986 } 987 988 /* If not already a bitvect, convert value to a bitvect */ 989 val = intnum_tobv(op1static, intn); 990 991 return size_leb128(val, sign); 992 } 993 994 unsigned long 995 yasm_get_sleb128(long v, unsigned char *ptr) 996 { 997 wordptr val = op1static; 998 999 /* Shortcut 0 */ 1000 if (v == 0) { 1001 *ptr = 0; 1002 return 1; 1003 } 1004 1005 BitVector_Empty(val); 1006 if (v >= 0) 1007 BitVector_Chunk_Store(val, 32, 0, (unsigned long)v); 1008 else { 1009 BitVector_Chunk_Store(val, 32, 0, (unsigned long)(-v)); 1010 BitVector_Negate(val, val); 1011 } 1012 return get_leb128(val, ptr, 1); 1013 } 1014 1015 unsigned long 1016 yasm_size_sleb128(long v) 1017 { 1018 wordptr val = op1static; 1019 1020 if (v == 0) 1021 return 1; 1022 1023 BitVector_Empty(val); 1024 if (v >= 0) 1025 BitVector_Chunk_Store(val, 32, 0, (unsigned long)v); 1026 else { 1027 BitVector_Chunk_Store(val, 32, 0, (unsigned long)(-v)); 1028 BitVector_Negate(val, val); 1029 } 1030 return size_leb128(val, 1); 1031 } 1032 1033 unsigned long 1034 yasm_get_uleb128(unsigned long v, unsigned char *ptr) 1035 { 1036 wordptr val = op1static; 1037 1038 /* Shortcut 0 */ 1039 if (v == 0) { 1040 *ptr = 0; 1041 return 1; 1042 } 1043 1044 BitVector_Empty(val); 1045 BitVector_Chunk_Store(val, 32, 0, v); 1046 return get_leb128(val, ptr, 0); 1047 } 1048 1049 unsigned long 1050 yasm_size_uleb128(unsigned long v) 1051 { 1052 wordptr val = op1static; 1053 1054 if (v == 0) 1055 return 1; 1056 1057 BitVector_Empty(val); 1058 BitVector_Chunk_Store(val, 32, 0, v); 1059 return size_leb128(val, 0); 1060 } 1061 1062 char * 1063 yasm_intnum_get_str(const yasm_intnum *intn) 1064 { 1065 unsigned char *s; 1066 1067 switch (intn->type) { 1068 case INTNUM_L: 1069 s = yasm_xmalloc(16); 1070 sprintf((char *)s, "%ld", intn->val.l); 1071 return (char *)s; 1072 break; 1073 case INTNUM_BV: 1074 return (char *)BitVector_to_Dec(intn->val.bv); 1075 break; 1076 } 1077 /*@notreached@*/ 1078 return NULL; 1079 } 1080 1081 void 1082 yasm_intnum_print(const yasm_intnum *intn, FILE *f) 1083 { 1084 unsigned char *s; 1085 1086 switch (intn->type) { 1087 case INTNUM_L: 1088 fprintf(f, "0x%lx", intn->val.l); 1089 break; 1090 case INTNUM_BV: 1091 s = BitVector_to_Hex(intn->val.bv); 1092 fprintf(f, "0x%s", (char *)s); 1093 yasm_xfree(s); 1094 break; 1095 } 1096 } 1097
