1/* 2 * Some or all of this work - Copyright (c) 2006 - 2016, Intel Corp. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without modification, 6 * are permitted provided that the following conditions are met: 7 * 8 * Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * Neither the name of Intel Corporation nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 25 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 26 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29/* 30 * Integer arithmetic 31 */ 32 33Name(z083, 83) 34 35// Verifying 2-parameters, 1-result operator 36Method(m000, 6, Serialized) 37{ 38 Store(0, Local5) 39 Store(arg1, Local3) 40 41 While(Local3) { 42 43 // Operands 44 45 Multiply(Local5, 2, Local6) 46 Store(DeRefOf(Index(arg3, Local6)), Local0) 47 Increment(Local6) 48 Store(DeRefOf(Index(arg3, Local6)), Local1) 49 50 // Expected result 51 52 Store(DeRefOf(Index(arg4, Local5)), Local2) 53 54 switch (ToInteger (arg5)) { 55 case (0) { 56 Add(Local0, Local1, Local7) 57 if (LNotEqual(Local7, Local2)) { 58 err(arg0, z083, 0, 0, 0, Local5, arg2) 59 } 60 Add(Local1, Local0, Local7) 61 if (LNotEqual(Local7, Local2)) { 62 err(arg0, z083, 1, 0, 0, Local5, arg2) 63 } 64 } 65 case (1) { 66 Subtract(Local0, Local1, Local7) 67 if (LNotEqual(Local7, Local2)) { 68 err(arg0, z083, 2, 0, 0, Local5, arg2) 69 } 70 } 71 case (2) { 72 Multiply(Local0, Local1, Local7) 73 if (LNotEqual(Local7, Local2)) { 74 err(arg0, z083, 3, 0, 0, Local5, arg2) 75 } 76 Multiply(Local1, Local0, Local7) 77 if (LNotEqual(Local7, Local2)) { 78 err(arg0, z083, 4, 0, 0, Local5, arg2) 79 } 80 } 81 case (3) { 82 And(Local0, Local1, Local7) 83 if (LNotEqual(Local7, Local2)) { 84 err(arg0, z083, 5, 0, 0, Local5, arg2) 85 } 86 And(Local1, Local0, Local7) 87 if (LNotEqual(Local7, Local2)) { 88 err(arg0, z083, 6, 0, 0, Local5, arg2) 89 } 90 } 91 case (4) { 92 Nand(Local0, Local1, Local7) 93 if (LNotEqual(Local7, Local2)) { 94 err(arg0, z083, 7, 0, 0, Local5, arg2) 95 } 96 Nand(Local1, Local0, Local7) 97 if (LNotEqual(Local7, Local2)) { 98 err(arg0, z083, 8, 0, 0, Local5, arg2) 99 } 100 } 101 case (5) { 102 Nor(Local0, Local1, Local7) 103 if (LNotEqual(Local7, Local2)) { 104 err(arg0, z083, 9, 0, 0, Local5, arg2) 105 } 106 Nor(Local1, Local0, Local7) 107 if (LNotEqual(Local7, Local2)) { 108 err(arg0, z083, 10, 0, 0, Local5, arg2) 109 } 110 } 111 case (6) { 112 Or(Local0, Local1, Local7) 113 if (LNotEqual(Local7, Local2)) { 114 err(arg0, z083, 11, 0, 0, Local5, arg2) 115 } 116 Or(Local1, Local0, Local7) 117 if (LNotEqual(Local7, Local2)) { 118 err(arg0, z083, 12, 0, 0, Local5, arg2) 119 } 120 } 121 case (7) { 122 Xor(Local0, Local1, Local7) 123 if (LNotEqual(Local7, Local2)) { 124 err(arg0, z083, 13, 0, 0, Local5, arg2) 125 } 126 Xor(Local1, Local0, Local7) 127 if (LNotEqual(Local7, Local2)) { 128 err(arg0, z083, 14, 0, 0, Local5, arg2) 129 } 130 } 131 case (8) { 132 Mod(Local0, Local1, Local7) 133 if (LNotEqual(Local7, Local2)) { 134 err(arg0, z083, 15, 0, 0, Local5, arg2) 135 } 136 } 137 case (9) { 138 ShiftLeft(Local0, Local1, Local7) 139 if (LNotEqual(Local7, Local2)) { 140 err(arg0, z083, 16, 0, 0, Local5, arg2) 141 } 142 } 143 case (10) { 144 ShiftRight(Local0, Local1, Local7) 145 if (LNotEqual(Local7, Local2)) { 146 err(arg0, z083, 17, 0, 0, Local5, arg2) 147 } 148 } 149 } 150 Increment(Local5) 151 Decrement(Local3) 152 } 153} 154 155// Verifying 2-parameters, 2-results operator 156Method(m001, 6, Serialized) 157{ 158 Store(0, Local5) 159 Store(arg1, Local4) 160 161 While(Local4) { 162 163 // Operands 164 165 Multiply(Local5, 2, Local6) 166 Store(DeRefOf(Index(arg3, Local6)), Local0) 167 Increment(Local6) 168 Store(DeRefOf(Index(arg3, Local6)), Local1) 169 170 // Expected result 171 172 Multiply(Local5, 2, Local6) 173 Store(DeRefOf(Index(arg4, Local6)), Local2) 174 Increment(Local6) 175 Store(DeRefOf(Index(arg4, Local6)), Local3) 176 177 switch (ToInteger (arg5)) { 178 case (0) { 179 Divide(Local0, Local1, Local6, Local7) 180 if (LNotEqual(Local7, Local2)) { 181 err(arg0, z083, 18, 0, 0, Local5, arg2) 182 } 183 if (LNotEqual(Local6, Local3)) { 184 err(arg0, z083, 19, 0, 0, Local5, arg2) 185 } 186 } 187 } 188 Increment(Local5) 189 Decrement(Local4) 190 } 191} 192 193// Verifying 1-parameter, 1-result operator 194Method(m002, 6, Serialized) 195{ 196 Store(0, Local5) 197 Store(arg1, Local3) 198 199 While(Local3) { 200 201 // Operand 202 203 Store(DeRefOf(Index(arg3, Local5)), Local0) 204 205 // Expected result 206 207 Store(DeRefOf(Index(arg4, Local5)), Local1) 208 209 switch (ToInteger (arg5)) { 210 case (0) { 211 Increment(Local0) 212 if (LNotEqual(Local0, Local1)) { 213 err(arg0, z083, 20, 0, 0, Local5, arg2) 214 } 215 } 216 case (1) { 217 Decrement(Local0) 218 if (LNotEqual(Local0, Local1)) { 219 err(arg0, z083, 21, 0, 0, Local5, arg2) 220 } 221 } 222 case (2) { 223 Not(Local0, Local2) 224 if (LNotEqual(Local2, Local1)) { 225 err(arg0, z083, 22, 0, 0, Local5, arg2) 226 } 227 } 228 case (3) { 229 FindSetLeftBit(Local0, Local2) 230 if (LNotEqual(Local2, Local1)) { 231 err(arg0, z083, 23, 0, 0, Local5, arg2) 232 } 233 } 234 case (4) { 235 FindSetRightBit(Local0, Local2) 236 if (LNotEqual(Local2, Local1)) { 237 err(arg0, z083, 24, 0, 0, Local5, arg2) 238 } 239 } 240 } 241 Increment(Local5) 242 Decrement(Local3) 243 } 244} 245 246// =================================== // 247// Bitwise operands // 248// // 249// (utilized by different operators) // 250// =================================== // 251 252Name(p030, Package() 253{ 254 0, 0, 255 0, 0xffffffff, 256 0xffffffff, 0xffffffff, 257 0xf0f0f0f0, 0xffffffff, 258 0x0f0f0f0f, 0xffffffff, 259 0xf0f0f0f0, 0, 260 0x0f0f0f0f, 0, 261 0xf0f0f0f0, 0x11111111, 262 0x0f0f0f0f, 0x11111111, 263 0x87654321, 0x90abcdfe, 264}) 265 266Name(p031, Package() 267{ 268 0, 0, 269 0, 0xffffffffffffffff, 270 0xffffffffffffffff, 0xffffffffffffffff, 271 0xf0f0f0f0f0f0f0f0, 0xffffffffffffffff, 272 0x0f0f0f0f0f0f0f0f, 0xffffffffffffffff, 273 0xf0f0f0f0f0f0f0f0, 0, 274 0x0f0f0f0f0f0f0f0f, 0, 275 0xf0f0f0f0f0f0f0f0, 0x1111111111111111, 276 0x0f0f0f0f0f0f0f0f, 0x1111111111111111, 277 0x8765432199118822, 0x90ab66887799cdfe, 278}) 279 280Name(p032, Package() 281{ 282 0, 283 0xffffffff, 284 0xf0f0f0f0, 285 0x0f0f0f0f, 286 0x12345678, 287}) 288 289Name(p033, Package() 290{ 291 0, 292 0xffffffffffffffff, 293 0xf0f0f0f0f0f0f0f0, 294 0x0f0f0f0f0f0f0f0f, 295 0x123456780af9bced, 296}) 297 298// ===================================== Add 299 300Name(p000, Package() 301{ 302 0x12345678, 0x6bcdef01, 303 0x62345678, 0x4bcdef01, 304 0x00000000, 0x00000000, 305 0x10000000, 0x90000000, 306 0x00000000, 0x000000ff, 307 0x00000000, 0x0000ffff, 308 0x00000000, 0xffffffff, 309 310 // 32-overflow 311 0x12345678, 0xf0000000, 312 0xffffffff, 0xffffffff, 313 0x00000001, 0xffffffff, 314}) 315 316Name(p001, Package() 317{ 318 0x7E024579, 319 0xAE024579, 320 0x00000000, 321 0xa0000000, 322 0x000000ff, 323 0x0000ffff, 324 0xffffffff, 325 326 // 32-overflow 327 0x02345678, 328 0xfffffffe, 329 0x00000000, 330}) 331 332Name(p002, Package() 333{ 334 // 32-overflow 335 0x12345678, 0xf0000000, 336 0xffffffff, 0xffffffff, 337 338 0x12345678dcabef98, 0x6bcdef0119283746, 339 0x72345678dcabef98, 0x5bcdef0119283746, 340 0, 0, 341 0x1000000000000000, 0x9000000000000000, 342 0, 0x0ff, 343 0, 0x0ffff, 344 0, 0x0ffffffff, 345 0, 0xffffffffffffffff, 346 347 // 64-overflow 348 0x12345678dcabef98, 0xf000000000000000, 349 0xffffffffffffffff, 0xffffffffffffffff, 350 1, 0xffffffffffffffff, 351}) 352 353Name(p003, Package() 354{ 355 // 32-overflow 356 0x102345678, 357 0x1fffffffe, 358 359 0x7E024579F5D426DE, 360 0xCE024579F5D426DE, 361 0, 362 0xa000000000000000, 363 0x0ff, 364 0x0ffff, 365 0x0ffffffff, 366 0xffffffffffffffff, 367 368 // 64-overflow 369 0x02345678DCABEF98, 370 0xfffffffffffffffe, 371 0, 372}) 373 374Method(ADD0,, Serialized) 375{ 376 Name(ts, "ADD0") 377 378 Store("TEST: ADD0, Integer Add", Debug) 379 380 if (LEqual(F64, 1)) { 381 m000(ts, 7, "p000", p000, p001, 0) 382 m000(ts, 13, "p002", p002, p003, 0) 383 } else { 384 m000(ts, 10, "p000", p000, p001, 0) 385 } 386} 387 388// ===================================== Subtract 389 390Name(p004, Package() 391{ 392 0x62345678, 0x4bcdef01, 393 0x00000000, 0x00000000, 394 0x90000000, 0x10000000, 395 0x000000ff, 0x00000000, 396 0x0000ffff, 0x00000000, 397 0xffffffff, 0xffffffff, 398 0xffffffff, 0x00000000, 399 400 // 32-overflow 401 0x00000000, 0x87654321, 402 0x12345678, 0x6bcdef01, 403 0x10000000, 0x90000000, 404 0x00000000, 0x000000ff, 405 0x00000000, 0x0000ffff, 406}) 407 408Name(p005, Package() 409{ 410 0x16666777, 411 0x00000000, 412 0x80000000, 413 0x000000ff, 414 0x0000ffff, 415 0x00000000, 416 0xffffffff, 417 418 // 32-overflow 419 0x789ABCDF, 420 0xA6666777, 421 0x80000000, 422 0xFFFFFF01, 423 0xFFFF0001 424}) 425 426Name(p006, Package() 427{ 428 // 32-overflow 429 0x00000000, 0x87654321, 430 0x12345678, 0x6bcdef01, 431 0x10000000, 0x90000000, 432 0x00000000, 0x000000ff, 433 0x00000000, 0x0000ffff, 434 435 0x12345678dcabef98, 0x6bcdef0119283746, 436 0x72345678dcabef98, 0x5bcdef0119283746, 437 0, 0, 438 0xffffffffffffffff, 0, 439 0, 0xffffffffffffffff, 440 0x9000000000000000, 0x1000000000000000, 441 0x1000000000000000, 0x9000000000000000, 442 0x0ff, 0, 443 0, 0x0ff, 444 0x0ffff, 0, 445 0, 0x0ffff, 446 0x0ffffffff, 0, 447 0, 0x0ffffffff, 448 0xffffffffffffffff, 0xffffffffffffffff, 449 0x12345678dcabef98, 0xf000000000000000, 450}) 451 452Name(p007, Package() 453{ 454 // 32-overflow 455 0xFFFFFFFF789ABCDF, 456 0xFFFFFFFFA6666777, 457 0xFFFFFFFF80000000, 458 0xFFFFFFFFFFFFFF01, 459 0xFFFFFFFFFFFF0001, 460 461 0xA6666777C383B852, 462 0x16666777C383B852, 463 0, 464 0xffffffffffffffff, 465 1, 466 0x8000000000000000, 467 0x8000000000000000, 468 0x0ff, 469 0xFFFFFFFFFFFFFF01, 470 0x0ffff, 471 0xFFFFFFFFFFFF0001, 472 0x0ffffffff, 473 0xFFFFFFFF00000001, 474 0, 475 0x22345678DCABEF98 476}) 477 478Method(SUB0,, Serialized) 479{ 480 Name(ts, "SUB0") 481 482 Store("TEST: SUB0, Integer Subtract", Debug) 483 484 if (LEqual(F64, 1)) { 485 m000(ts, 7, "p004", p004, p005, 1) 486 m000(ts, 20, "p006", p006, p007, 1) 487 } else { 488 m000(ts, 12, "p004", p004, p005, 1) 489 } 490} 491 492// ===================================== Multiply 493 494Name(p008, Package() 495{ 496 0, 0, 497 0, 0xffffffff, 498 0x00012345, 0x00007abc, 499 0x00000012, 0x00000034, 500 0x00000001, 0x000000ff, 501 0x00000001, 0x0000ffff, 502 0x00000001, 0xffffffff, 503 504 // bit-size of multiplicand 505 0x67812345, 2, 506 507 // bit-size of multiplier 508 3, 0x45678123, 509 510 0xffffffff, 0xffffffff, 511 512 // ACPI: Overflow conditions are ignored and results are undefined. 513}) 514 515Name(p009, Package() 516{ 517 0, 518 0, 519 0x8BA4C8AC, 520 0x000003a8, 521 0x000000ff, 522 0x0000ffff, 523 0xffffffff, 524 525 // bit-size of multiplicand 526 0xCF02468A, 527 528 // bit-size of multiplier 529 0xD0368369, 530 531 0x00000001 532 533 // ACPI: Overflow conditions are ignored and results are undefined. 534}) 535 536Name(p00a, Package() 537{ 538 0x092345678, 0x0abcdef68, 539 0x0f2345678, 0x0abcdef68, 540 541 0, 0xffffffffffffffff, 542 543 1, 0xffffffffffffffff, 544 545 // bit-size of multiplicand 546 0x6781234511992288, 2, 547 548 // bit-size of multiplier 549 3, 0x4567812377665544, 550 551 0xffffffffffffffff, 0xffffffffffffffff, 552 553 // ACPI: Overflow conditions are ignored and results are undefined. 554}) 555 556Name(p00b, Package() 557{ 558 0x621E9265A81528C0, 559 0xA28BCC2CA81528C0, 560 0, 561 562 0xffffffffffffffff, 563 564 // bit-size of multiplicand 565 0xCF02468A23324510, 566 567 // bit-size of multiplier 568 0xD036836A6632FFCC, 569 570 0x0000000000000001 571 572 // ACPI: Overflow conditions are ignored and results are undefined. 573}) 574 575Method(MTP0,, Serialized) 576{ 577 Name(ts, "MTP0") 578 579 Store("TEST: MTP0, Integer Multiply", Debug) 580 581 if (LEqual(F64, 1)) { 582 m000(ts, 9, "p008", p008, p009, 2) 583 m000(ts, 7, "p00a", p00a, p00b, 2) 584 } else { 585 m000(ts, 10, "p008", p008, p009, 2) 586 } 587} 588 589// ===================================== Divide 590 591Name(p00c, Package() 592{ 593 // divident divisor 594 0x12345678, 0x1000, 595 0xffffffff, 0x400000, 596 // bit-size of operands 597 0x78123456, 0x80000000, 598 0x78123456, 2, 599 0, 1, 600 0x78123456, 0x11223344, 601 // bit-size of result 602 0xffffffff, 1, 603 // bit-size of remainder 604 0xffffffff, 0x80000000, 605}) 606 607Name(p00d, Package() 608{ 609 // result remainder 610 0x12345, 0x678, 611 0x3ff, 0x3fffff, 612 0, 0x78123456, 613 0x3C091A2B, 0, 614 0, 0, 615 7, 0x22cd7a, 616 0xffffffff, 0, 617 1, 0x7fffffff, 618}) 619 620Name(p00e, Package() 621{ 622 // divident divisor 623 624 0x1234567811223344, 0x1000, 625 0xffffffffffffffff, 0x4000000000000000, 626 0x7812345699887766, 0x8000000000000000, 627 0x7812345600448866, 2, 628 0, 1, 629 0x78123456aabbccdd, 0x110022bd33ca4784, 630 0xffffffffffffffff, 1, 631 0xffffffffffffffff, 0x8000000000000000, 632}) 633 634Name(p00f, Package() 635{ 636 // result remainder 637 0x0001234567811223, 0x344, 638 3, 0x3FFFFFFFFFFFFFFF, 639 0, 0x7812345699887766, 640 0x3C091A2B00224433, 0, 641 0, 0, 642 7, 0x0111412A4033D841, 643 0xffffffffffffffff, 0, 644 1, 0x7FFFFFFFFFFFFFFF, 645}) 646 647Method(DVD0,, Serialized) 648{ 649 Name(ts, "DVD0") 650 651 Store("TEST: DVD0, Integer Divide", Debug) 652 653 if (LEqual(F64, 1)) { 654 m001(ts, 8, "p00c", p00c, p00d, 0) 655 m001(ts, 8, "p00e", p00e, p00f, 0) 656 } else { 657 m001(ts, 8, "p00c", p00c, p00d, 0) 658 } 659} 660 661// ===================================== Increment 662 663Name(p014, Package() 664{ 665 0, 666 0xfffffffe, 667 0x12334579, 668 0x7fffffff, 669 0x80000000, 670 0xffffffff, 671}) 672 673Name(p015, Package() 674{ 675 1, 676 0xffffffff, 677 0x1233457a, 678 0x80000000, 679 0x80000001, 680 0, 681}) 682 683Name(p016, Package() 684{ 685 0xffffffff, 686 687 0xfffffffffffffffe, 688 0x1233457988339042, 689 0x7fffffffffffffff, 690 0x8000000000000000, 691 0xffffffffffffffff, 692}) 693 694Name(p017, Package() 695{ 696 0x100000000, 697 698 0xffffffffffffffff, 699 0x1233457988339043, 700 0x8000000000000000, 701 0x8000000000000001, 702 0, 703}) 704 705Method(ICR0,, Serialized) 706{ 707 Name(ts, "ICR0") 708 709 Store("TEST: ICR0, Increment an Integer", Debug) 710 711 if (LEqual(F64, 1)) { 712 m002(ts, 5, "p014", p014, p015, 0) 713 m002(ts, 6, "p016", p016, p017, 0) 714 } else { 715 m002(ts, 6, "p014", p014, p015, 0) 716 } 717} 718 719// ===================================== Decrement 720 721Name(p018, Package() 722{ 723 0xffffffff, 724 0x12334579, 725 0x80000000, 726 0x7fffffff, 727 0x80000001, 728 0, 729}) 730 731Name(p019, Package() 732{ 733 0xfffffffe, 734 0x12334578, 735 0x7fffffff, 736 0x7ffffffe, 737 0x80000000, 738 0xffffffff, 739}) 740 741Name(p01a, Package() 742{ 743 0, 744 0xffffffffffffffff, 745 0x1233457966887700, 746 0x8000000000000000, 747 0x7fffffffffffffff, 748 0x8000000000000001, 749}) 750 751Name(p01b, Package() 752{ 753 0xffffffffffffffff, 754 0xfffffffffffffffe, 755 0x12334579668876ff, 756 0x7fffffffffffffff, 757 0x7ffffffffffffffe, 758 0x8000000000000000, 759}) 760 761Method(DCR0,, Serialized) 762{ 763 Name(ts, "DCR0") 764 765 Store("TEST: DCR0, Decrement an Integer", Debug) 766 767 if (LEqual(F64, 1)) { 768 m002(ts, 5, "p018", p018, p019, 1) 769 m002(ts, 6, "p01a", p01a, p01b, 1) 770 } else { 771 m002(ts, 6, "p018", p018, p019, 1) 772 } 773} 774 775// ===================================== And 776 777Name(p01c, Package() 778{ 779 0, 780 0, 781 0xffffffff, 782 0xf0f0f0f0, 783 0x0f0f0f0f, 784 0, 785 0, 786 0x10101010, 787 0x01010101, 788 0x80214120, 789}) 790 791Name(p01d, Package() 792{ 793 0, 794 0, 795 0xffffffffffffffff, 796 0xf0f0f0f0f0f0f0f0, 797 0x0f0f0f0f0f0f0f0f, 798 0, 799 0, 800 0x1010101010101010, 801 0x0101010101010101, 802 0x8021420011118822, 803}) 804 805Method(AND0,, Serialized) 806{ 807 Name(ts, "AND0") 808 809 Store("TEST: AND0, Integer Bitwise And", Debug) 810 811 if (LEqual(F64, 1)) { 812 m000(ts, c000, "p030", p030, p01c, 3) 813 m000(ts, c000, "p031", p031, p01d, 3) 814 } else { 815 m000(ts, c000, "p030", p030, p01c, 3) 816 } 817} 818 819// ===================================== Nand 820 821Name(p01e, Package() {0x9a3353ac, 0x39a966ca}) 822Name(p01f, Package() {0xE7DEBD77}) 823Name(p020, Package() {0xffffffffE7DEBD77}) 824Name(p021, Package() {0x9a3353ac395c9353, 0x39a966caa36a3a66}) 825Name(p022, Package() {0xE7DEBD77DEB7EDBD}) 826 827Name(p023, Package() 828{ 829 0xffffffff, 830 0xffffffff, 831 0, 832 0x0f0f0f0f, 833 0xf0f0f0f0, 834 0xffffffff, 835 0xffffffff, 836 0xefefefef, 837 0xfefefefe, 838 0x7FDEBEDF, 839}) 840 841Name(p024, Package() 842{ 843 0xffffffffffffffff, 844 0xffffffffffffffff, 845 0xffffffff00000000, 846 0xffffffff0f0f0f0f, 847 0xfffffffff0f0f0f0, 848 0xffffffffffffffff, 849 0xffffffffffffffff, 850 0xffffffffefefefef, 851 0xfffffffffefefefe, 852 0xFFFFFFFF7FDEBEDF, 853}) 854 855Name(p025, Package() 856{ 857 0xffffffffffffffff, 858 0xffffffffffffffff, 859 0, 860 0x0f0f0f0f0f0f0f0f, 861 0xf0f0f0f0f0f0f0f0, 862 0xffffffffffffffff, 863 0xffffffffffffffff, 864 0xefefefefefefefef, 865 0xfefefefefefefefe, 866 0x7FDEBDFFEEEE77DD, 867}) 868 869Method(NAN0,, Serialized) 870{ 871 Name(ts, "NAN0") 872 873 Store("TEST: NAN0, Integer Bitwise Nand", Debug) 874 875 if (LEqual(F64, 1)) { 876 m000(ts, 1, "p01e", p01e, p020, 4) 877 m000(ts, 1, "p021", p021, p022, 4) 878 m000(ts, c000, "p030", p030, p024, 4) 879 m000(ts, c000, "p031", p031, p025, 4) 880 } else { 881 m000(ts, 1, "p01e", p01e, p01f, 4) 882 m000(ts, c000, "p030", p030, p023, 4) 883 } 884} 885 886// ===================================== Nor 887 888Name(p026, Package() {0x9a3353ac, 0x39a966ca}) 889Name(p027, Package() {0x44448811}) 890Name(p028, Package() {0xffffffff44448811}) 891Name(p029, Package() {0x9a3353ac993ca39c, 0x39a966ca3356a5c9}) 892Name(p02a, Package() {0x4444881144815822}) 893 894Name(p02b, Package() 895{ 896 0xffffffff, 897 0, 898 0, 899 0, 900 0, 901 0x0f0f0f0f, 902 0xf0f0f0f0, 903 0x0e0e0e0e, 904 0xe0e0e0e0, 905 0x68103000, 906}) 907 908Name(p02c, Package() 909{ 910 0xffffffffffffffff, 911 0xffffffff00000000, 912 0xffffffff00000000, 913 0xffffffff00000000, 914 0xffffffff00000000, 915 0xffffffff0f0f0f0f, 916 0xfffffffff0f0f0f0, 917 0xffffffff0e0e0e0e, 918 0xffffffffe0e0e0e0, 919 0xFFFFFFFF68103000, 920}) 921 922Name(p02d, Package() 923{ 924 0xffffffffffffffff, 925 0, 926 0, 927 0, 928 0, 929 0x0f0f0f0f0f0f0f0f, 930 0xf0f0f0f0f0f0f0f0, 931 0x0e0e0e0e0e0e0e0e, 932 0xe0e0e0e0e0e0e0e0, 933 0x6810985600663201, 934}) 935 936Method(NOR0,, Serialized) 937{ 938 Name(ts, "NOR0") 939 940 Store("TEST: NOR0, Integer Bitwise Nor", Debug) 941 942 if (LEqual(F64, 1)) { 943 m000(ts, 1, "p026", p026, p028, 5) 944 m000(ts, 1, "p029", p029, p02a, 5) 945 m000(ts, c000, "p030", p030, p02c, 5) 946 m000(ts, c000, "p031", p031, p02d, 5) 947 } else { 948 m000(ts, 1, "p026", p026, p027, 5) 949 m000(ts, c000, "p030", p030, p02b, 5) 950 } 951} 952 953// ===================================== Not 954 955Name(p02e, Package() 956{ 957 0xffffffff, 958 0, 959 0x0f0f0f0f, 960 0xf0f0f0f0, 961 0xEDCBA987, 962}) 963 964Name(p02f, Package() 965{ 966 0xffffffffffffffff, 967 0xffffffff00000000, 968 0xffffffff0f0f0f0f, 969 0xfffffffff0f0f0f0, 970 0xffffffffEDCBA987, 971}) 972 973Name(p040, Package() 974{ 975 0xffffffffffffffff, 976 0, 977 0x0f0f0f0f0f0f0f0f, 978 0xf0f0f0f0f0f0f0f0, 979 0xEDCBA987F5064312, 980}) 981 982Method(NOT0,, Serialized) 983{ 984 Name(ts, "NOT0") 985 986 Store("TEST: NOT0, Integer Bitwise Not", Debug) 987 988 if (LEqual(F64, 1)) { 989 m002(ts, c001, "p032", p032, p02f, 2) 990 m002(ts, c001, "p033", p033, p040, 2) 991 } else { 992 m002(ts, c001, "p032", p032, p02e, 2) 993 } 994} 995 996// ===================================== Or 997 998Name(p041, Package() {0x9a3353ac, 0x39a966ca}) 999Name(p042, Package() {0xBBBB77EE}) 1000Name(p043, Package() {0x9a3353ac99a3dceb, 0x39a966ca12887634}) 1001Name(p044, Package() {0xBBBB77EE9BABFEFF}) 1002 1003Name(p045, Package() 1004{ 1005 0, 1006 0xffffffff, 1007 0xffffffff, 1008 0xffffffff, 1009 0xffffffff, 1010 0xf0f0f0f0, 1011 0x0f0f0f0f, 1012 0xf1f1f1f1, 1013 0x1f1f1f1f, 1014 0x97EFCFFF, 1015}) 1016 1017Name(p046, Package() 1018{ 1019 0, 1020 0xffffffffffffffff, 1021 0xffffffffffffffff, 1022 0xffffffffffffffff, 1023 0xffffffffffffffff, 1024 0xf0f0f0f0f0f0f0f0, 1025 0x0f0f0f0f0f0f0f0f, 1026 0xf1f1f1f1f1f1f1f1, 1027 0x1f1f1f1f1f1f1f1f, 1028 0x97EF67A9FF99CDFE, 1029}) 1030 1031Method(OR00,, Serialized) 1032{ 1033 Name(ts, "OR00") 1034 1035 Store("TEST: OR00, Integer Bitwise Or", Debug) 1036 1037 if (LEqual(F64, 1)) { 1038 m000(ts, 1, "p041", p041, p042, 6) 1039 m000(ts, 1, "p043", p043, p044, 6) 1040 m000(ts, c000, "p030", p030, p045, 6) 1041 m000(ts, c000, "p031", p031, p046, 6) 1042 } else { 1043 m000(ts, 1, "p041", p041, p042, 6) 1044 m000(ts, c000, "p030", p030, p045, 6) 1045 } 1046} 1047 1048// ===================================== Xor 1049 1050Name(p047, Package() {0x9a3653ac, 0x39a966ca}) 1051Name(p048, Package() {0xA39F3566}) 1052Name(p049, Package() {0x9a3653ac19283745, 0x39a966cabbaaef45}) 1053Name(p04a, Package() {0xA39F3566A282D800}) 1054 1055Name(p04b, Package() 1056{ 1057 0, 1058 0xffffffff, 1059 0, 1060 0x0f0f0f0f, 1061 0xf0f0f0f0, 1062 0xf0f0f0f0, 1063 0x0f0f0f0f, 1064 0xe1e1e1e1, 1065 0x1e1e1e1e, 1066 0x17CE8EDF, 1067}) 1068 1069Name(p04c, Package() 1070{ 1071 0, 1072 0xffffffffffffffff, 1073 0, 1074 0x0f0f0f0f0f0f0f0f, 1075 0xf0f0f0f0f0f0f0f0, 1076 0xf0f0f0f0f0f0f0f0, 1077 0x0f0f0f0f0f0f0f0f, 1078 0xe1e1e1e1e1e1e1e1, 1079 0x1e1e1e1e1e1e1e1e, 1080 0x17CE25A9EE8845DC, 1081}) 1082 1083Name(p04d, Package() 1084{ 1085 0, 1086 0xffffffff, 1087 0, 1088 0x0f0f0f0f, 1089 0xf0f0f0f0, 1090 0xf0f0f0f0, 1091 0x0f0f0f0f, 1092 0xe1e1e1e1, 1093 0x1e1e1e1e, 1094 0x17CE8EDF, 1095}) 1096 1097Method(XOR0,, Serialized) 1098{ 1099 Name(ts, "XOR0") 1100 1101 Store("TEST: XOR0, Integer Bitwise Xor", Debug) 1102 1103 if (LEqual(F64, 1)) { 1104 m000(ts, 1, "p047", p047, p048, 7) 1105 m000(ts, 1, "p049", p049, p04a, 7) 1106 m000(ts, c000, "p030", p030, p04b, 7) 1107 1108 1109 m000(ts, 1, "p031", p031, p04c, 7) 1110 m000(ts, c000, "p031", p031, p04c, 7) 1111 } else { 1112 m000(ts, 1, "p047", p047, p048, 7) 1113 m000(ts, c000, "p030", p030, p04d, 7) 1114 } 1115} 1116 1117// ===================================== Mod 1118 1119Name(p04e, Package() 1120{ 1121 // remainder 1122 0x678, 1123 0x3fffff, 1124 0x78123456, 1125 0, 1126 0, 1127 0x22cd7a, 1128 0, 1129 0x7fffffff, 1130}) 1131 1132Name(p04f, Package() 1133{ 1134 // remainder 1135 0x344, 1136 0x3FFFFFFFFFFFFFFF, 1137 0x7812345699887766, 1138 0, 1139 0, 1140 0x0111412A4033D841, 1141 0, 1142 0x7FFFFFFFFFFFFFFF, 1143}) 1144 1145Method(MOD0,, Serialized) 1146{ 1147 Name(ts, "MOD0") 1148 1149 Store("TEST: MOD0, Integer Modulo", Debug) 1150 1151 if (LEqual(F64, 1)) { 1152 m000(ts, 8, "p00c", p00c, p04e, 8) 1153 m000(ts, 8, "p00e", p00e, p04f, 8) 1154 } else { 1155 m000(ts, 8, "p00c", p00c, p04e, 8) 1156 } 1157} 1158 1159// ===================================== ShiftLeft 1160 1161Name(p050, Package() 1162{ 1163 0, 0, 1164 0, 1, 1165 0, 17, 1166 0, 31, 1167 0, 32, 1168 0, 33, 1169 0, 64, 1170 0, 65, 1171 1172 0xffffffff, 0, 1173 0xffffffff, 1, 1174 0xffffffff, 14, 1175 0xffffffff, 31, 1176 0xffffffff, 32, 1177 0xffffffff, 33, 1178 0xffffffff, 64, 1179 0xffffffff, 65, 1180 1181 0xf0f0f0f0, 0, 1182 0xf0f0f0f0, 1, 1183 0xf0f0f0f0, 17, 1184 0xf0f0f0f0, 31, 1185 0xf0f0f0f0, 32, 1186 1187 0x87654321, 0, 1188 0x87654321, 1, 1189 0x87654321, 17, 1190 0x87654321, 31, 1191 0x87654321, 32, 1192}) 1193 1194Name(p051, Package() 1195{ 1196 0, 1197 0, 1198 0, 1199 0, 1200 0, 1201 0, 1202 0, 1203 0, 1204 1205 0xffffffff, 1206 0xfffffffe, 1207 0xFFFFC000, 1208 0x80000000, 1209 0, 1210 0, 1211 0, 1212 0, 1213 1214 0xf0f0f0f0, 1215 0xe1e1e1e0, 1216 0xE1E00000, 1217 0, 1218 0, 1219 1220 0x87654321, 1221 0x0ECA8642, 1222 0x86420000, 1223 0x80000000, 1224 0, 1225}) 1226 1227Name(p052, Package() 1228{ 1229 0, 1230 0, 1231 0, 1232 0, 1233 0, 1234 0, 1235 0, 1236 0, 1237 1238 0x00000000ffffffff, 1239 0x00000001fffffffe, 1240 0x00003FFFFFFFC000, 1241 0x7fffffff80000000, 1242 0xFFFFFFFF00000000, 1243 0xFFFFFFFE00000000, 1244 0, 1245 0, 1246 1247 0xf0f0f0f0, 1248 0x00000001E1E1E1E0, 1249 0x0001E1E1E1E00000, 1250 0x7878787800000000, 1251 0xF0F0F0F000000000, 1252 1253 0x87654321, 1254 0x000000010ECA8642, 1255 0x00010ECA86420000, 1256 0x43B2A19080000000, 1257 0x8765432100000000, 1258}) 1259 1260Name(p053, Package() 1261{ 1262 0xffffffffffffffff, 0, 1263 0xffffffffffffffff, 1, 1264 0xffffffffffffffff, 17, 1265 0xffffffffffffffff, 49, 1266 0xffffffffffffffff, 64, 1267 0xffffffffffffffff, 65, 1268 1269 0xf0f0f0f0f0f0f0f0, 15, 1270 0xf0f0f0f0f0f0f0f0, 35, 1271 1272 0x87654321bcdef098, 11, 1273 0x87654321bcdef098, 50, 1274}) 1275 1276Name(p054, Package() 1277{ 1278 0xffffffffffffffff, 1279 0xfffffffffffffffe, 1280 0xFFFFFFFFFFFE0000, 1281 0xFFFE000000000000, 1282 0, 1283 0, 1284 1285 0x7878787878780000, 1286 0x8787878000000000, 1287 1288 0x2A190DE6F784C000, 1289 0xC260000000000000, 1290}) 1291 1292Method(SHL0,, Serialized) 1293{ 1294 Name(ts, "SHL0") 1295 1296 Store("TEST: SHL0, Integer shift value left", Debug) 1297 1298 if (LEqual(F64, 1)) { 1299 m000(ts, 26, "p050", p050, p052, 9) 1300 m000(ts, 10, "p053", p053, p054, 9) 1301 } else { 1302 m000(ts, 26, "p050", p050, p051, 9) 1303 } 1304} 1305 1306// ===================================== ShiftRight 1307 1308Name(p055, Package() 1309{ 1310 0, 1311 0, 1312 0, 1313 0, 1314 0, 1315 0, 1316 0, 1317 0, 1318 1319 0xffffffff, 1320 0x7fffffff, 1321 0x0003FFFF, 1322 0x00000001, 1323 0, 1324 0, 1325 0, 1326 0, 1327 1328 0xf0f0f0f0, 1329 0x78787878, 1330 0x00007878, 1331 0x00000001, 1332 0, 1333 1334 0x87654321, 1335 0x43B2A190, 1336 0x000043B2, 1337 0x00000001, 1338 0, 1339}) 1340 1341Name(p056, Package() 1342{ 1343 0xffffffffffffffff, 1344 0x7fffffffffffffff, 1345 0x00007FFFFFFFFFFF, 1346 0x0000000000007FFF, 1347 0, 1348 0, 1349 1350 0x0001E1E1E1E1E1E1, 1351 0x000000001E1E1E1E, 1352 1353 0x0010ECA864379BDE, 1354 0x00000000000021D9, 1355}) 1356 1357Method(SHR0,, Serialized) 1358{ 1359 Name(ts, "SHR0") 1360 1361 Store("TEST: SHR0, Integer shift value right", Debug) 1362 1363 if (LEqual(F64, 1)) { 1364 m000(ts, 26, "p050", p050, p055, 10) 1365 m000(ts, 10, "p053", p053, p056, 10) 1366 } else { 1367 m000(ts, 26, "p050", p050, p055, 10) 1368 } 1369} 1370 1371// ===================================== FindSetLeftBit 1372 1373Name(p057, Package() 1374{ 1375 0, 1376 0xffffffff, 1377 0x80000000, 1378 0x00000001, 1379 0x02a0fd40, 1380 0x0456f200, 1381}) 1382 1383Name(p058, Package() 1384{ 1385 0, 1386 32, 1387 32, 1388 1, 1389 26, 1390 27, 1391}) 1392 1393Name(p059, Package() 1394{ 1395 0, 1396 0xffffffffffffffff, 1397 0x8000000000000000, 1398 0x0000000000000001, 1399 0x02a0fd4119fd0560, 1400 0x0456f2007ced8400, 1401}) 1402 1403Name(p05a, Package() 1404{ 1405 0, 1406 64, 1407 64, 1408 1, 1409 58, 1410 59, 1411}) 1412 1413Method(FSL0,, Serialized) 1414{ 1415 Name(ts, "FSL0") 1416 1417 Store("TEST: FSL0, Index of first least significant bit set", Debug) 1418 1419 if (LEqual(F64, 1)) { 1420 m002(ts, 6, "p057", p057, p058, 3) 1421 m002(ts, 6, "p059", p059, p05a, 3) 1422 } else { 1423 m002(ts, 6, "p057", p057, p058, 3) 1424 } 1425 1426 if (LEqual(F64, 1)) { 1427 Store(64, Local0) 1428 } else { 1429 Store(32, Local0) 1430 } 1431 Store(0, Local1) 1432 Store(0, Local5) 1433 1434 While (Local0) { 1435 if (LEqual(Local1, 0)) { 1436 Store(1, Local2) 1437 } else { 1438 ShiftLeft(3, Local5, Local2) 1439 Increment(Local5) 1440 } 1441 FindSetLeftBit(Local2, Local3) 1442 Add(Local1, 1, Local4) 1443 if (LNotEqual(Local3, Local4)) { 1444 err(ts, z083, 25, 0, 0, Local0, 0) 1445 } 1446 Increment(Local1) 1447 Decrement(Local0) 1448 } 1449} 1450 1451// ===================================== FindSetRightBit 1452 1453Name(p05b, Package() 1454{ 1455 0, 1456 1, 1457 32, 1458 1, 1459 7, 1460 10, 1461}) 1462 1463Name(p05c, Package() 1464{ 1465 0, 1466 1, 1467 64, 1468 1, 1469 6, 1470 11, 1471}) 1472 1473Method(FSR0,, Serialized) 1474{ 1475 Name(ts, "FSR0") 1476 1477 Store("TEST: FSR0, Index of first most significant bit set", Debug) 1478 1479 if (LEqual(F64, 1)) { 1480 m002(ts, 6, "p057", p057, p05b, 4) 1481 m002(ts, 6, "p059", p059, p05c, 4) 1482 } else { 1483 m002(ts, 6, "p057", p057, p05b, 4) 1484 } 1485 1486 if (LEqual(F64, 1)) { 1487 Store(64, Local0) 1488 } else { 1489 Store(32, Local0) 1490 } 1491 Store(0, Local1) 1492 Store(0, Local5) 1493 1494 While (Local0) { 1495 if (LEqual(Local1, 0)) { 1496 Store(1, Local2) 1497 Store(1, Local4) 1498 } else { 1499 ShiftLeft(3, Local5, Local2) 1500 Store(Local1, Local4) 1501 Increment(Local5) 1502 } 1503 FindSetRightBit(Local2, Local3) 1504 if (LNotEqual(Local3, Local4)) { 1505 err(ts, z083, 26, 0, 0, Local0, 0) 1506 } 1507 Increment(Local1) 1508 Decrement(Local0) 1509 } 1510} 1511