diff --git a/test/libsolidity/semanticTests/mlir/abi-encode-packed-nested-fixed-array.sol b/test/libsolidity/semanticTests/mlir/abi-encode-packed-nested-fixed-array.sol new file mode 100644 index 000000000..8dd4cb50c --- /dev/null +++ b/test/libsolidity/semanticTests/mlir/abi-encode-packed-nested-fixed-array.sol @@ -0,0 +1,61 @@ +contract C { + uint16[2][3] nestedU16; + uint256[4][5][4] nestedU256; + + constructor() { + nestedU16[0][0] = 1; + nestedU16[0][1] = 2; + nestedU16[1][0] = 3; + nestedU16[1][1] = 4; + nestedU16[2][0] = 5; + nestedU16[2][1] = 6; + + uint256 value = 1; + for (uint256 i = 0; i < 4; ++i) { + for (uint256 j = 0; j < 5; ++j) { + for (uint256 k = 0; k < 4; ++k) + nestedU256[i][j][k] = value++; + } + } + } + + function ep_nested_u16_memory(uint16[2][3] memory x) public pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u16_calldata(uint16[2][3] calldata x) external pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u16_storage() external view returns (bytes memory) { + return abi.encodePacked(nestedU16); + } + + function ep_nested_u256_memory(uint256[4][5][4] memory x) public pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u256_calldata(uint256[4][5][4] calldata x) external pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u256_storage() external view returns (bytes memory) { + return abi.encodePacked(nestedU256); + } + + function ep_nested_addr_memory(address[2][2] memory x) public pure returns (bytes memory) { + return abi.encodePacked(x); + } +} + +// ==== +// compileViaMlir: true +// ---- +// constructor() -> +// ep_nested_u16_memory(uint16[2][3]): 1, 2, 3, 4, 5, 6 -> 32, 192, 1, 2, 3, 4, 5, 6 +// ep_nested_u16_calldata(uint16[2][3]): 1, 2, 3, 4, 5, 6 -> 32, 192, 1, 2, 3, 4, 5, 6 +// ep_nested_u16_storage() -> 32, 192, 1, 2, 3, 4, 5, 6 +// ep_nested_u256_memory(uint256[4][5][4]): 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 -> 32, 2560, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 +// ep_nested_u256_calldata(uint256[4][5][4]): 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 -> 32, 2560, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 +// ep_nested_u256_storage() -> 32, 2560, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 +// ep_nested_addr_memory(address[2][2]): 1, 2, 3, 4 -> 32, 128, 1, 2, 3, 4 diff --git a/test/libsolidity/semanticTests/mlir/abi-encode-packed-storage-array.sol b/test/libsolidity/semanticTests/mlir/abi-encode-packed-storage-array.sol new file mode 100644 index 000000000..3b2506ca8 --- /dev/null +++ b/test/libsolidity/semanticTests/mlir/abi-encode-packed-storage-array.sol @@ -0,0 +1,85 @@ +contract C { + uint256[] dyn256; + uint128[] dyn128; + uint8[] dyn8; + + uint256[10] static256x10; + uint128[3] static128x3; + uint8[31] static8x31; + uint8[32] static8x32; + uint8[33] static8x33; + + constructor() { + dyn256.push(0x11); + dyn256.push(0x22); + + dyn128.push(0x1234); + dyn128.push(0x5678); + dyn128.push(0x9abc); + + dyn8.push(1); + dyn8.push(2); + dyn8.push(3); + dyn8.push(4); + + for (uint256 i = 0; i < 10; ++i) + static256x10[i] = i + 1; + + for (uint256 i = 0; i < 3; ++i) + static128x3[i] = uint128((i + 1) * 16); + + for (uint256 i = 0; i < 31; ++i) + static8x31[i] = uint8(i + 1); + + for (uint256 i = 0; i < 32; ++i) + static8x32[i] = uint8(i + 1); + + for (uint256 i = 0; i < 33; ++i) + static8x33[i] = uint8(i + 1); + } + + function ep_u256_array_dynamic_storage() public view returns (bytes memory) { + return abi.encodePacked(dyn256); + } + + function ep_u128_array_dynamic_storage() public view returns (bytes memory) { + return abi.encodePacked(dyn128); + } + + function ep_u8_array_dynamic_storage() public view returns (bytes memory) { + return abi.encodePacked(dyn8); + } + + function ep_u256_array_static_storage() public view returns (bytes memory) { + return abi.encodePacked(static256x10); + } + + function ep_u128_array_static_storage() public view returns (bytes memory) { + return abi.encodePacked(static128x3); + } + + function ep_u8_array_static_storage_31() public view returns (bytes memory) { + return abi.encodePacked(static8x31); + } + + function ep_u8_array_static_storage_32() public view returns (bytes memory) { + return abi.encodePacked(static8x32); + } + + function ep_u8_array_static_storage_33() public view returns (bytes memory) { + return abi.encodePacked(static8x33); + } +} + +// ==== +// compileViaMlir: true +// ---- +// constructor() -> +// ep_u256_array_dynamic_storage() -> 32, 64, 17, 34 +// ep_u128_array_dynamic_storage() -> 32, 96, 4660, 22136, 39612 +// ep_u8_array_dynamic_storage() -> 32, 128, 1, 2, 3, 4 +// ep_u256_array_static_storage() -> 32, 320, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 +// ep_u128_array_static_storage() -> 32, 96, 16, 32, 48 +// ep_u8_array_static_storage_31() -> 32, 992, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 +// ep_u8_array_static_storage_32() -> 32, 1024, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 +// ep_u8_array_static_storage_33() -> 32, 1056, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33 diff --git a/test/libsolidity/semanticTests/mlir/abi-encode-storage-array.sol b/test/libsolidity/semanticTests/mlir/abi-encode-storage-array.sol new file mode 100644 index 000000000..45107babe --- /dev/null +++ b/test/libsolidity/semanticTests/mlir/abi-encode-storage-array.sol @@ -0,0 +1,133 @@ +contract C { + struct U256Pair { + uint256 left; + uint256 right; + } + + uint256[] dyn256; + + uint8[4] static8x4; + uint8[31] static8x31; + uint8[32] static8x32; + uint8[33] static8x33; + uint256[3] static256x3; + + uint256[][] dynRefDyn256; + uint256[2][] dynRefStatic2x; + uint256[][2] staticRefDyn256x2; + U256Pair[] dynStructPair; + U256Pair[2] staticStructPair2; + + constructor() { + dyn256.push(11); + dyn256.push(22); + dyn256.push(33); + + static8x4[0] = 1; + static8x4[1] = 2; + static8x4[2] = 3; + static8x4[3] = 4; + + for (uint256 i = 0; i < 31; ++i) + static8x31[i] = uint8(i + 1); + + for (uint256 i = 0; i < 32; ++i) + static8x32[i] = uint8(i + 1); + + for (uint256 i = 0; i < 33; ++i) + static8x33[i] = uint8(i + 1); + + static256x3[0] = 1; + static256x3[1] = 2; + static256x3[2] = 3; + + dynRefDyn256.push(); + dynRefDyn256[0].push(101); + dynRefDyn256[0].push(202); + dynRefDyn256.push(); + dynRefDyn256[1].push(303); + + dynRefStatic2x.push(); + dynRefStatic2x[0][0] = 10; + dynRefStatic2x[0][1] = 20; + dynRefStatic2x.push(); + dynRefStatic2x[1][0] = 30; + dynRefStatic2x[1][1] = 40; + + staticRefDyn256x2[0].push(7); + staticRefDyn256x2[0].push(8); + staticRefDyn256x2[1].push(9); + + dynStructPair.push(); + dynStructPair[0].left = 111; + dynStructPair[0].right = 222; + dynStructPair.push(); + dynStructPair[1].left = 333; + dynStructPair[1].right = 444; + + staticStructPair2[0].left = 555; + staticStructPair2[0].right = 666; + staticStructPair2[1].left = 777; + staticStructPair2[1].right = 888; + } + + function ei_u256_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dyn256); + } + + function ei_u8_array_static_storage_4() public view returns (bytes memory) { + return abi.encode(static8x4); + } + + function ei_u8_array_static_storage_31() public view returns (bytes memory) { + return abi.encode(static8x31); + } + + function ei_u8_array_static_storage_32() public view returns (bytes memory) { + return abi.encode(static8x32); + } + + function ei_u8_array_static_storage_33() public view returns (bytes memory) { + return abi.encode(static8x33); + } + + function ei_u256_array_static_storage_3() public view returns (bytes memory) { + return abi.encode(static256x3); + } + + function ei_u256_array_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dynRefDyn256); + } + + function ei_u256x2_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dynRefStatic2x); + } + + function ei_u256_array_static_storage_2() public view returns (bytes memory) { + return abi.encode(staticRefDyn256x2); + } + + function ei_u256_pair_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dynStructPair); + } + + function ei_u256_pair_array_static_storage_2() public view returns (bytes memory) { + return abi.encode(staticStructPair2); + } +} + +// ==== +// compileViaMlir: true +// ---- +// constructor() -> +// ei_u256_array_dynamic_storage() -> 0x20, 160, 0x20, 3, 11, 22, 33 +// ei_u8_array_static_storage_4() -> 0x20, 128, 1, 2, 3, 4 +// ei_u8_array_static_storage_31() -> 0x20, 992, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 +// ei_u8_array_static_storage_32() -> 0x20, 1024, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 +// ei_u8_array_static_storage_33() -> 0x20, 1056, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33 +// ei_u256_array_static_storage_3() -> 0x20, 96, 1, 2, 3 +// ei_u256_array_array_dynamic_storage() -> 0x20, 288, 0x20, 2, 0x40, 0xa0, 2, 101, 202, 1, 303 +// ei_u256x2_array_dynamic_storage() -> 0x20, 192, 0x20, 2, 10, 20, 30, 40 +// ei_u256_array_static_storage_2() -> 0x20, 256, 0x20, 0x40, 0xa0, 2, 7, 8, 1, 9 +// ei_u256_pair_array_dynamic_storage() -> 0x20, 192, 0x20, 2, 111, 222, 333, 444 +// ei_u256_pair_array_static_storage_2() -> 0x20, 128, 555, 666, 777, 888 diff --git a/test/libsolidity/semanticTests/mlir/abi-encode-struct.sol b/test/libsolidity/semanticTests/mlir/abi-encode-struct.sol index 612ee90d3..3a6b97ac3 100644 --- a/test/libsolidity/semanticTests/mlir/abi-encode-struct.sol +++ b/test/libsolidity/semanticTests/mlir/abi-encode-struct.sol @@ -32,8 +32,13 @@ contract C { uint256 d; } - // FIXME: Enable storage encoding tests with Big/Nested once storage-array - // encoding is fixed. + struct S { + uint256 a; + uint256 b; + } + + Big storageBig; + Nested storageBigNested; StorageFlat storageFlat; StorageNested storageNested; StoragePacked storagePacked; @@ -53,6 +58,25 @@ contract C { storagePacked.b = 2; storagePacked.c = true; storagePacked.d = 3; + + storageBig.id = 7; + storageBig.code = 8; + storageBig.note = "abc"; + storageBig.fixedArr[0] = 41; + storageBig.fixedArr[1] = 42; + storageBig.dynArr.push(11); + storageBig.dynArr.push(12); + storageBig.dynArr.push(13); + + storageBigNested.salt = 100; + storageBigNested.payload.id = 5; + storageBigNested.payload.code = 6; + storageBigNested.payload.note = "xy"; + storageBigNested.payload.fixedArr[0] = 21; + storageBigNested.payload.fixedArr[1] = 22; + storageBigNested.payload.dynArr.push(31); + storageBigNested.payload.dynArr.push(32); + storageBigNested.extra = 200; } function mem_big(Big memory s) public pure returns (bytes memory) { @@ -71,6 +95,18 @@ contract C { return abi.encode(s); } + function enc_struct(S[2] calldata x) public pure returns (bytes memory) { + return abi.encode(x); + } + + function storage_big() public view returns (bytes memory) { + return abi.encode(storageBig); + } + + function storage_big_nested() public view returns (bytes memory) { + return abi.encode(storageBigNested); + } + function storage_flat() public view returns (bytes memory) { return abi.encode(storageFlat); } @@ -92,6 +128,9 @@ contract C { // cd_big((uint256,uint256,string,uint256[2],uint256[])): 0x20, 7, 8, 0xc0, 41, 42, 0x100, 3, "abc", 3, 11, 12, 13 -> 0x20, 0x1a0, 0x20, 7, 8, 0xc0, 41, 42, 0x100, 3, "abc", 3, 11, 12, 13 // mem_nested((uint256,(uint256,uint256,string,uint256[2],uint256[]),uint256)): 0x20, 100, 0x60, 200, 5, 6, 0xc0, 21, 22, 0x100, 2, "xy", 2, 31, 32 -> 0x20, 0x1e0, 0x20, 100, 0x60, 200, 5, 6, 0xc0, 21, 22, 0x100, 2, "xy", 2, 31, 32 // cd_nested((uint256,(uint256,uint256,string,uint256[2],uint256[]),uint256)): 0x20, 100, 0x60, 200, 5, 6, 0xc0, 21, 22, 0x100, 2, "xy", 2, 31, 32 -> 0x20, 0x1e0, 0x20, 100, 0x60, 200, 5, 6, 0xc0, 21, 22, 0x100, 2, "xy", 2, 31, 32 +// enc_struct((uint256,uint256)[2]): 11, 22, 33, 44 -> 0x20, 0x80, 11, 22, 33, 44 +// storage_big() -> 0x20, 0x1a0, 0x20, 7, 8, 0xc0, 41, 42, 0x100, 3, "abc", 3, 11, 12, 13 +// storage_big_nested() -> 0x20, 0x1e0, 0x20, 100, 0x60, 200, 5, 6, 0xc0, 21, 22, 0x100, 2, "xy", 2, 31, 32 // storage_flat() -> 0x20, 0xc0, 0x20, 9, 10, 0x60, 4, "stor" // storage_nested() -> 0x20, 288, 0x20, 0x64, 0x60, 300, 0xc9, 0xca, 0x60, 2, 47687202278368593055453199545051370742183790376672955679702151372887807754240 // storage_packed() -> 0x20, 0x80, 1, 2, 1, 3 diff --git a/test/libsolidity/semanticTests/mlir/abi-encode-tail-cleanup.sol b/test/libsolidity/semanticTests/mlir/abi-encode-tail-cleanup.sol new file mode 100644 index 000000000..d019b7221 --- /dev/null +++ b/test/libsolidity/semanticTests/mlir/abi-encode-tail-cleanup.sol @@ -0,0 +1,173 @@ +contract C { + function tail_after_encode_bytes_memory(bytes memory x) public pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encode allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x60), not(0)) + mstore(add(p, 0x80), not(0)) + mstore(0x40, p) + } + + out = abi.encode(x); + uint256 tail; + assembly { + let payload := add(out, 0x20) + let len := mload(add(payload, 0x20)) + tail := mload(add(add(payload, 0x40), len)) + } + return tail; + } + + function tail_after_encode_bytes_calldata(bytes calldata x) external pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encode allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x60), not(0)) + mstore(add(p, 0x80), not(0)) + mstore(0x40, p) + } + + out = abi.encode(x); + uint256 tail; + assembly { + let payload := add(out, 0x20) + let len := mload(add(payload, 0x20)) + tail := mload(add(add(payload, 0x40), len)) + } + return tail; + } + + function tail_after_encode_string_memory(string memory x) public pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encode allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x60), not(0)) + mstore(add(p, 0x80), not(0)) + mstore(0x40, p) + } + + out = abi.encode(x); + uint256 tail; + assembly { + let payload := add(out, 0x20) + let len := mload(add(payload, 0x20)) + tail := mload(add(add(payload, 0x40), len)) + } + return tail; + } + + function tail_after_encode_string_calldata(string calldata x) external pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encode allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x60), not(0)) + mstore(add(p, 0x80), not(0)) + mstore(0x40, p) + } + + out = abi.encode(x); + uint256 tail; + assembly { + let payload := add(out, 0x20) + let len := mload(add(payload, 0x20)) + tail := mload(add(add(payload, 0x40), len)) + } + return tail; + } + + function tail_after_packed_bytes_memory(bytes memory x) public pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encodePacked allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x20), not(0)) + mstore(add(p, 0x40), not(0)) + mstore(0x40, p) + } + + out = abi.encodePacked(x); + uint256 tail; + assembly { + tail := mload(add(add(out, 0x20), mload(out))) + } + return tail; + } + + function tail_after_packed_bytes_calldata(bytes calldata x) external pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encodePacked allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x20), not(0)) + mstore(add(p, 0x40), not(0)) + mstore(0x40, p) + } + + out = abi.encodePacked(x); + uint256 tail; + assembly { + tail := mload(add(add(out, 0x20), mload(out))) + } + return tail; + } + + function tail_after_packed_string_memory(string memory x) public pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encodePacked allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x20), not(0)) + mstore(add(p, 0x40), not(0)) + mstore(0x40, p) + } + + out = abi.encodePacked(x); + uint256 tail; + assembly { + tail := mload(add(add(out, 0x20), mload(out))) + } + return tail; + } + + function tail_after_packed_string_calldata(string calldata x) external pure returns (uint256) { + bytes memory out; + + assembly { + // Force abi.encodePacked allocation to reuse dirty memory. + let p := mload(0x40) + mstore(add(p, 0x20), not(0)) + mstore(add(p, 0x40), not(0)) + mstore(0x40, p) + } + + out = abi.encodePacked(x); + uint256 tail; + assembly { + tail := mload(add(add(out, 0x20), mload(out))) + } + return tail; + } +} + +// ==== +// compileViaMlir: true +// ---- +// tail_after_encode_bytes_memory(bytes): 0x20, 3, "abc" -> 0 +// tail_after_encode_bytes_calldata(bytes): 0x20, 3, "abc" -> 0 +// tail_after_encode_string_memory(string): 0x20, 3, "abc" -> 0 +// tail_after_encode_string_calldata(string): 0x20, 3, "abc" -> 0 +// tail_after_packed_bytes_memory(bytes): 0x20, 3, "abc" -> 0 +// tail_after_packed_bytes_calldata(bytes): 0x20, 3, "abc" -> 0 +// tail_after_packed_string_memory(string): 0x20, 3, "abc" -> 0 +// tail_after_packed_string_calldata(string): 0x20, 3, "abc" -> 0 diff --git a/test/libsolidity/semanticTests/mlir/abi.sol b/test/libsolidity/semanticTests/mlir/abi.sol index bae51c49b..9b46146cd 100644 --- a/test/libsolidity/semanticTests/mlir/abi.sol +++ b/test/libsolidity/semanticTests/mlir/abi.sol @@ -21,6 +21,10 @@ contract C { return abi.decode(a, (uint, uint8, int32)); } + function di_calldata(bytes calldata a) public returns (uint, uint8, int32) { + return abi.decode(a, (uint, uint8, int32)); + } + function ep(uint ui, uint8 ui8, int32 si32) public returns (bytes memory) { return abi.encodePacked(ui, ui8, si32); } @@ -45,6 +49,10 @@ contract C { return abi.decode(a, (address)); } + function di_addr_calldata(bytes calldata a) public returns (address) { + return abi.decode(a, (address)); + } + function ep_addr(address a) public returns (bytes memory) { return abi.encodePacked(a); } @@ -57,6 +65,10 @@ contract C { return abi.decode(a, (address, uint256)); } + function di_addr_u256_calldata(bytes calldata a) public returns (address, uint256) { + return abi.decode(a, (address, uint256)); + } + function rt_addr(address a) public returns (address) { return abi.decode(abi.encode(a), (address)); } @@ -80,6 +92,10 @@ contract C { return abi.decode(a, (CC)); } + function di_contract_calldata(bytes calldata a) public returns (CC) { + return abi.decode(a, (CC)); + } + function ep_contract(CC c) public returns (bytes memory) { return abi.encodePacked(c); } @@ -88,6 +104,10 @@ contract C { return abi.decode(a, (CC, uint256)); } + function di_contract_u256_calldata(bytes calldata a) public returns (CC, uint256) { + return abi.decode(a, (CC, uint256)); + } + function rt_contract(CC c) public returns (CC) { return abi.decode(abi.encode(c), (CC)); } @@ -175,6 +195,10 @@ contract C { return abi.encode(x); } + function enc_nested(uint256[2][3] calldata x) public returns (bytes memory) { + return abi.encode(x); + } + function ep_addr_array_dynamic_calldata(address[] calldata x) public returns (bytes memory) { return abi.encodePacked(x); } @@ -315,22 +339,27 @@ contract C { // ---- // ei(uint256,uint8,int32): 1, 2, -1 -> 32, 96, 1, 2, -1 // di(bytes): 32, 96, 1, 2, -1 -> 1, 2, -1 +// di_calldata(bytes): 32, 96, 1, 2, -1 -> 1, 2, -1 // ep(uint256,uint8,int32): 1, 2, -1 -> 32, 37, 1, left(0x02ffffffff) // ep_empty() -> 32, 0 // ep_u256(uint256): 1 -> 32, 32, 1 // ep_u256x2(uint256,uint256): 1, 2 -> 32, 64, 1, 2 // ei_addr(address): 1 -> 32, 32, 1 // di_addr(bytes): 32, 32, 1 -> 1 +// di_addr_calldata(bytes): 32, 32, 1 -> 1 // ep_addr(address): 1 -> 32, 20, left(0x0000000000000000000000000000000000000001) // ei_addr_u256(address,uint256): 1, 7 -> 32, 64, 1, 7 // di_addr_u256(bytes): 32, 64, 1, 7 -> 1, 7 +// di_addr_u256_calldata(bytes): 32, 64, 1, 7 -> 1, 7 // rt_addr(address): 1 -> 1 // rt_addr_u256(address,uint256): 1, 7 -> 1, 7 // rt_addr_payable(address): 1 -> 1 // ei_contract(address): 1 -> 32, 32, 1 // di_contract(bytes): 32, 32, 1 -> 1 +// di_contract_calldata(bytes): 32, 32, 1 -> 1 // ep_contract(address): 1 -> 32, 20, left(0x0000000000000000000000000000000000000001) // di_contract_u256(bytes): 32, 64, 1, 7 -> 1, 7 +// di_contract_u256_calldata(bytes): 32, 64, 1, 7 -> 1, 7 // rt_contract(address): 1 -> 1 // ep_u8_len(uint8): 1 -> 1 // ep_u8(uint8): 1 -> 32, 1, left(0x01) @@ -370,6 +399,7 @@ contract C { // ei_bool_array_dynamic_calldata(bool[]): 0x20, 2, 2, 0 -> FAILURE // ei_u8_array_nested_dynamic_calldata(uint8[][]): 0x20, 2, 0x40, 0xC0, 3, 13, 17, 23, 4, 27, 31, 37, 41 -> 32, 416, 32, 2, 64, 192, 3, 13, 17, 23, 4, 27, 31, 37, 41 // ei_u8_array_nested_dynamic_calldata(uint8[][]): 0x20, 2, 0x40, 0xC0, 3, 0xFF13, 17, 23, 4, 27, 31, 37, 41 -> FAILURE +// enc_nested(uint256[2][3]): 1, 2, 3, 4, 5, 6 -> 0x20, 0xc0, 1, 2, 3, 4, 5, 6 // ep_enum_array_dynamic_calldata(uint8[]): 0x20, 3, 0, 1, 2 -> 0x20, 0x60, left(0x00), 1, 2 // ep_enum_array_dynamic_calldata(uint8[]): 0x20, 1, 3 -> FAILURE // ei_enum_array_dynamic_calldata(uint8[]): 0x20, 3, 0, 1, 2 -> 32, 160, 32, 3, 0, 1, 2 diff --git a/test/libsolidity/semanticTests/mlir/enum.sol b/test/libsolidity/semanticTests/mlir/enum.sol index baeaad0f2..62a31e0ac 100644 --- a/test/libsolidity/semanticTests/mlir/enum.sol +++ b/test/libsolidity/semanticTests/mlir/enum.sol @@ -23,7 +23,7 @@ contract C { // ---- // id(uint8): 0 -> 0 // id(uint8): 2 -> 2 -// id(uint8): 3 -> FAILURE, hex"4e487b71", 0x21 +// id(uint8): 3 -> FAILURE // cmp(uint8,uint8): 0, 1 -> false, true // cmp(uint8,uint8): 2, 2 -> true, false // toUint(uint8): 2 -> 2 diff --git a/test/libsolidity/semanticTests/mlir/invalid-abi.sol b/test/libsolidity/semanticTests/mlir/invalid-abi.sol index d36c233ee..d638a5e94 100644 --- a/test/libsolidity/semanticTests/mlir/invalid-abi.sol +++ b/test/libsolidity/semanticTests/mlir/invalid-abi.sol @@ -16,6 +16,14 @@ contract C { return a; } + function c(uint[] calldata a) external returns (uint256) { + return a[0]; + } + + function d(uint256[][2] calldata a) external returns (uint256) { + return 1; + } + function e() public returns (uint256) { bytes memory data = hex"00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000"; abi.decode(data, (string[2])); @@ -30,6 +38,18 @@ contract C { return abi.encode(s); } + function ec_arr(uint256[][2] calldata x) external returns (bytes memory) { + return abi.encode(x); + } + + function ec_arr_dyn(uint256[][] calldata x) external returns (bytes memory) { + return abi.encode(x); + } + + function ec_arr_nested(uint256[][2][] calldata x) external returns (bytes memory) { + return abi.encode(x); + } + function sm(S memory s) external returns (uint256) { return s.a; } @@ -44,10 +64,21 @@ contract C { // h(uint256[][]): 32, 2, 0x200, 0xa0, 2, 1, 2, 2, 9, 8 -> FAILURE, hex"08c379a0", 0x20, 0x2b, "ABI decoding: invalid calldata a", "rray offset" // h(uint256[][]): 32, 1, 0x10000000000000000 -> FAILURE, hex"08c379a0", 0x20, 0x2b, "ABI decoding: invalid calldata a", "rray offset" // h(uint256[][]): 32, 1, 32, 3618502788666131106986593281521497120414687020801267626233049500247285301248 -> FAILURE, hex"4e487b71", 0x41 +// c(uint256[]): 0x20, 0x8000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"08c379a0", 0x20, 0x2b, "ABI decoding: invalid calldata a", "rray length" +// d(uint256[][2]): 0x20, 0x40 -> FAILURE, hex"08c379a0", 0x20, 0x2b, "ABI decoding: invalid calldata a", "rray stride" // e() -> FAILURE, hex"08c379a0", 0x20, 0x2b, "ABI decoding: invalid calldata a", "rray stride" // sc((uint256,string)): 0x20, 1 -> FAILURE, hex"08c379a0", 0x20, 0x27, "ABI decoding: struct calldata to", "o short" // ec((uint256,string)): 0x20, 1, 0x100, 0x80 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access offset" // ec((uint256,string)): 0x20, 1, 0x40, 0x10000000000000000 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access length" // ec((uint256,string)): 0x20, 1, 0x40, 2 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access stride" +// ec_arr(uint256[][2]): 0x20, 0x100, 0x40 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access offset" +// ec_arr(uint256[][2]): 0x20, 0x40, 0x80, 0x10000000000000000 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access length" +// ec_arr(uint256[][2]): 0x20, 0x40, 0x80, 2, 1 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access stride" +// ec_arr_dyn(uint256[][]): 0x20, 1, 0x100 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access offset" +// ec_arr_dyn(uint256[][]): 0x20, 1, 0x20, 0x10000000000000000 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access length" +// ec_arr_dyn(uint256[][]): 0x20, 1, 0x20, 2, 1 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access stride" +// ec_arr_nested(uint256[][2][]): 0x20, 1, 0x100 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access offset" +// ec_arr_nested(uint256[][2][]): 0x20, 1, 0x20, 0x40, 0x80, 0x10000000000000000 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access length" +// ec_arr_nested(uint256[][2][]): 0x20, 1, 0x20, 0x40, 0x80, 2, 1 -> FAILURE, hex"08c379a0", 0x20, 0x1e, "Invalid calldata access stride" // sm((uint256,string)): 0x20, 1 -> FAILURE, hex"08c379a0", 0x20, 0x23, "ABI decoding: struct data too sh", "ort" // sm((uint256,string)): 0x20, 1, 0x10000000000000000 -> FAILURE, hex"08c379a0", 0x20, 0x23, "ABI decoding: invalid struct off", "set" diff --git a/test/lit/mlirCodegen/EVM/abi-decode-struct.sol b/test/lit/mlirCodegen/EVM/abi-decode-struct.sol index be7b89412..e2e4e7148 100644 --- a/test/lit/mlirCodegen/EVM/abi-decode-struct.sol +++ b/test/lit/mlirCodegen/EVM/abi-decode-struct.sol @@ -42,6 +42,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -50,8 +57,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_106"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -59,22 +66,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_106() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_106_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_106_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_106_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_106_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -89,6 +110,9 @@ contract C { // CHECK-NEXT: %c127_i256 = arith.constant 127 : i256 loc(#loc) // CHECK-NEXT: %c164_i256 = arith.constant 164 : i256 loc(#loc) // CHECK-NEXT: %c131_i256 = arith.constant 131 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c196_i256 = arith.constant 196 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) @@ -99,25 +123,23 @@ contract C { // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) -// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256 = arith.constant 52195229743194479185619533901126580011012186126243431406710767645195241521152 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256 = arith.constant 29517451764962235613010368778373659638394623262010481743997880166685973898854 : i256 loc(#loc) -// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256 = arith.constant 50408947360703532628410820127875489391510599906502180640049823775688402927616 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256 = arith.constant 29517451764962235613010368778373660511553963533401470520153988868949248340840 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256 = arith.constant 45888551966424197807937402689295079693071411769653575580334356259971920822272 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256 = arith.constant 29517451764962235613010368778373659638394623262010481748738546747006033225331 : i256 loc(#loc) // CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) @@ -143,417 +165,470 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%131, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%147, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%131, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%147, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c196_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi ugt, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %20 = arith.addi %19, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %24 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %25 = arith.addi %13, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %19, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %25 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %13, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.addi %19, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %34 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %19 : i256 loc(#loc1) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %148 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%149, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %15, %33 : i256 loc(#loc1) -// CHECK-NEXT: %36 = arith.addi %35, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %37 = arith.cmpi sge, %36, %1 : i256 loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %13, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %19, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %13, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %19, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %33 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.cmpi ugt, %36, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %37 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %35 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %40, %39 : i256 loc(#loc1) -// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %42 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %38 = arith.addi %15, %36 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %38, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %40 = arith.cmpi sge, %39, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %40 { +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %39, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = arith.andi %43, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.cmpi ugt, %39, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %38 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = arith.addi %38, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %43, %42 : i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.cmpi ugt, %44, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %45 { -// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%133, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %44, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %48, %46 : i256 loc(#loc1) -// CHECK-NEXT: %50 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %49, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %39, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = arith.addi %48, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %40 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%53, %54, %39) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %52, %39 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %48, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %13, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %19, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %13, %c131_i256 : i256 loc(#loc1) -// CHECK-NEXT: %61 = arith.cmpi sge, %60, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %61 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.andi %46, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.cmpi ugt, %42, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %148 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%149, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.load %62 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %64 = arith.addi %63, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %64, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %66 = arith.addi %13, %c164_i256 : i256 loc(#loc1) -// CHECK-NEXT: %67 = arith.cmpi ugt, %66, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %67 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %52 = arith.andi %51, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %50, %52 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.cmpi ugt, %53, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.cmpi ult, %53, %50 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.ori %54, %55 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %56 { +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %148 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%149, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %68:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %63, %arg2 = %58) -> (i256, i256) { -// CHECK-NEXT: %131 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %132, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %134, %135 : i256, i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %53, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %42, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %50, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.inttoptr %43 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%60, %61, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %59, %42 : i256 loc(#loc1) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %50, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %13, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.addi %19, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %13, %c131_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = arith.cmpi sge, %67, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %68 { +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %63, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %70 = arith.addi %13, %c164_i256 : i256 loc(#loc1) -// CHECK-NEXT: %71 = arith.addi %19, %c128_i256 : i256 loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %70 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = arith.cmpi ugt, %73, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %70 = llvm.load %69 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %71 = arith.addi %70, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %72 = arith.cmpi ugt, %71, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %73 = arith.cmpi ult, %71, %70 : i256 loc(#loc1) +// CHECK-NEXT: %74 = arith.ori %72, %73 : i1 loc(#loc1) // CHECK-NEXT: scf.if %74 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %148 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%149, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %15, %73 : i256 loc(#loc1) -// CHECK-NEXT: %76 = arith.addi %75, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %77 = arith.cmpi sge, %76, %1 : i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %71, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %13, %c164_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = arith.cmpi ugt, %76, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %77 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %75 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %79 = llvm.load %78 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %80 = arith.addi %75, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %81 = arith.muli %79, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = arith.addi %80, %81 : i256 loc(#loc1) -// CHECK-NEXT: %83 = arith.cmpi ugt, %82, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %83 { -// CHECK-NEXT: %131 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %132, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = arith.addi %132, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %132, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %140 = arith.addi %132, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%142, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %78:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %70, %arg2 = %65) -> (i256, i256) { +// CHECK-NEXT: %147 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %148, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %150, %151 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %70, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %13, %c164_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = arith.addi %19, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %82 = llvm.inttoptr %80 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %83 = llvm.load %82 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %84 = arith.cmpi ugt, %83, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %84 { +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %84 = arith.muli %79, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %85 = arith.cmpi ugt, %79, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %85 { -// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%133, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %85 = arith.addi %15, %83 : i256 loc(#loc1) +// CHECK-NEXT: %86 = arith.addi %85, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %87 = arith.cmpi sge, %86, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %87 { +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %86 = arith.addi %84, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %87 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %89 = arith.addi %88, %86 : i256 loc(#loc1) -// CHECK-NEXT: %90 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %89, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %91 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %79, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %92 = arith.addi %88, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %93 = arith.index_castui %79 : i256 to index loc(#loc1) -// CHECK-NEXT: %94:2 = scf.for %arg0 = %c0 to %93 step %c1 iter_args(%arg1 = %92, %arg2 = %80) -> (i256, i256) { -// CHECK-NEXT: %131 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %132, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %134, %135 : i256, i256 loc(#loc1) +// CHECK-NEXT: %88 = llvm.inttoptr %85 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %89 = llvm.load %88 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %85, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = arith.muli %89, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %90, %91 : i256 loc(#loc1) +// CHECK-NEXT: %93 = arith.cmpi ugt, %92, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %93 { +// CHECK-NEXT: %147 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %148, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = arith.addi %148, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %152 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = arith.addi %148, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %148, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%158, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %95 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %88, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %96:5 = func.call @mem_big_54(%19) : (i256) -> (i256, i256, i256, i256, i256) loc(#loc1) -// CHECK-NEXT: %97 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %98 = llvm.load %97 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %99 = arith.addi %98, %c192_i256 : i256 loc(#loc1) -// CHECK-NEXT: %100 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %96#0, %100 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %101 = arith.addi %98, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %102 = llvm.inttoptr %101 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %96#1, %102 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %103 = arith.addi %98, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %104 = llvm.inttoptr %103 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c192_i256, %104 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %105 = arith.addi %98, %c224_i256 : i256 loc(#loc1) -// CHECK-NEXT: %106 = llvm.inttoptr %96#2 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %107 = llvm.load %106 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %108 = arith.addi %96#2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %109 = llvm.inttoptr %105 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %110 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%109, %110, %107) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %111 = llvm.inttoptr %99 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %107, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %112 = arith.addi %107, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %113 = arith.andi %112, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %114 = arith.addi %105, %113 : i256 loc(#loc1) -// CHECK-NEXT: %115 = arith.addi %98, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %116:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %115, %arg2 = %96#3) -> (i256, i256) { -// CHECK-NEXT: %131 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %132, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %134, %135 : i256, i256 loc(#loc1) +// CHECK-NEXT: %94 = arith.muli %89, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = arith.cmpi ugt, %89, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %95 { +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %148 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%149, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %117 = arith.addi %98, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %118 = arith.subi %114, %98 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %117 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %118, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = llvm.inttoptr %96#4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %97 = llvm.load %96 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %98 = arith.addi %94, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %99 = arith.andi %98, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %100 = arith.addi %97, %99 : i256 loc(#loc1) +// CHECK-NEXT: %101 = arith.cmpi ugt, %100, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %102 = arith.cmpi ult, %100, %97 : i256 loc(#loc1) +// CHECK-NEXT: %103 = arith.ori %101, %102 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %103 { +// CHECK-NEXT: %147 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %148 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%149, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %104 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %100, %104 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %105 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %89, %105 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %106 = arith.addi %97, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %107 = arith.index_castui %89 : i256 to index loc(#loc1) +// CHECK-NEXT: %108:2 = scf.for %arg0 = %c0 to %107 step %c1 iter_args(%arg1 = %106, %arg2 = %90) -> (i256, i256) { +// CHECK-NEXT: %147 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %148, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %150, %151 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %109 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %97, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %110:5 = func.call @mem_big_54(%19) : (i256) -> (i256, i256, i256, i256, i256) loc(#loc1) +// CHECK-NEXT: %111 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %112 = llvm.load %111 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %113 = arith.addi %112, %c192_i256 : i256 loc(#loc1) +// CHECK-NEXT: %114 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %110#0, %114 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %115 = arith.addi %112, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %116 = llvm.inttoptr %115 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %110#1, %116 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %117 = arith.addi %112, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %118 = llvm.inttoptr %117 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c192_i256, %118 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %119 = arith.addi %112, %c224_i256 : i256 loc(#loc1) +// CHECK-NEXT: %120 = llvm.inttoptr %110#2 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %121 = llvm.load %120 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %122 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %121, %122 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %123 = arith.index_castui %121 : i256 to index loc(#loc1) -// CHECK-NEXT: %124 = arith.addi %114, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %125 = arith.addi %96#4, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %126 = arith.muli %121, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %124, %126 : i256 loc(#loc1) -// CHECK-NEXT: %128:2 = scf.for %arg0 = %c0 to %123 step %c1 iter_args(%arg1 = %124, %arg2 = %125) -> (i256, i256) { -// CHECK-NEXT: %131 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %132, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %134 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %135 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %134, %135 : i256, i256 loc(#loc1) +// CHECK-NEXT: %122 = arith.addi %110#2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %123 = llvm.inttoptr %119 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %124 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%123, %124, %121) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %125 = arith.addi %119, %121 : i256 loc(#loc1) +// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %127 = llvm.inttoptr %113 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %121, %127 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %128 = arith.addi %121, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %129 = arith.andi %128, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %130 = arith.addi %119, %129 : i256 loc(#loc1) +// CHECK-NEXT: %131 = arith.addi %112, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %132:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %131, %arg2 = %110#3) -> (i256, i256) { +// CHECK-NEXT: %147 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %148, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %150, %151 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %133 = arith.addi %112, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %134 = arith.subi %130, %112 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %134, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = llvm.inttoptr %110#4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %137 = llvm.load %136 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %138 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %137, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %139 = arith.index_castui %137 : i256 to index loc(#loc1) +// CHECK-NEXT: %140 = arith.addi %130, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %141 = arith.addi %110#4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %142 = arith.muli %137, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %143 = arith.addi %140, %142 : i256 loc(#loc1) +// CHECK-NEXT: %144:2 = scf.for %arg0 = %c0 to %139 step %c1 iter_args(%arg1 = %140, %arg2 = %141) -> (i256, i256) { +// CHECK-NEXT: %147 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = llvm.load %147 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %148, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %150, %151 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %129 = arith.subi %127, %98 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%130, %129) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %145 = arith.subi %143, %112 : i256 loc(#loc1) +// CHECK-NEXT: %146 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%146, %145) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -561,435 +636,497 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %124 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%141, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %124 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%141, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c100_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi ugt, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %20 = arith.addi %19, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %24 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %25 = arith.addi %13, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %19, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %25 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.cmpi ugt, %28, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %29 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %19 : i256 loc(#loc1) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%143, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %15, %28 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.addi %30, %c192_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %1 : i256 loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %13, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %19, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %32 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %34, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %30 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %30, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %34, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %40 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %30, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %34, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %45 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.cmpi ugt, %48, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %49 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %15, %31 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %33, %c192_i256 : i256 loc(#loc1) +// CHECK-NEXT: %35 = arith.cmpi ugt, %34, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %35 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %30, %48 : i256 loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %50, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %52 = arith.cmpi sge, %51, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %52 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %38 = arith.addi %37, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.cmpi ugt, %38, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %40 = arith.cmpi ult, %38, %37 : i256 loc(#loc1) +// CHECK-NEXT: %41 = arith.ori %39, %40 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %41 { +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%143, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %50 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %38, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %33 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %44, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %33, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %37, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %46 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %50 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %49, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %33, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %37, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %51 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %50, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = arith.addi %55, %54 : i256 loc(#loc1) -// CHECK-NEXT: %57 = arith.cmpi ugt, %56, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %57 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %55 = arith.cmpi ugt, %54, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %54, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %59 = arith.andi %58, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = arith.cmpi ugt, %54, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %60 { -// CHECK-NEXT: %124 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %124 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %125 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%126, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %33, %54 : i256 loc(#loc1) +// CHECK-NEXT: %57 = arith.addi %56, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.cmpi sge, %57, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %58 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %59, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.load %62 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %64 = arith.addi %63, %61 : i256 loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %64, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %54, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %63, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = llvm.inttoptr %55 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%68, %69, %54) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %70 = arith.addi %67, %54 : i256 loc(#loc1) -// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %63, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = arith.addi %30, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %74 = arith.addi %34, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %30, %c127_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = arith.cmpi sge, %75, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %76 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %56 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %60 = llvm.load %59 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %56, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %61, %60 : i256 loc(#loc1) +// CHECK-NEXT: %63 = arith.cmpi ugt, %62, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %63 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %77 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %78 = llvm.load %77 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %78, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %79, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %30, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = arith.cmpi ugt, %81, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %82 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %64 = arith.addi %60, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %65 = arith.andi %64, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.cmpi ugt, %60, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %66 { +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%143, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %83:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %78, %arg2 = %73) -> (i256, i256) { -// CHECK-NEXT: %124 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %125, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %127, %128 : i256, i256 loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %65, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = arith.andi %69, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %71 = arith.addi %68, %70 : i256 loc(#loc1) +// CHECK-NEXT: %72 = arith.cmpi ugt, %71, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %73 = arith.cmpi ult, %71, %68 : i256 loc(#loc1) +// CHECK-NEXT: %74 = arith.ori %72, %73 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %74 { +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%143, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %78, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %85 = arith.addi %30, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %86 = arith.addi %34, %c128_i256 : i256 loc(#loc1) -// CHECK-NEXT: %87 = llvm.inttoptr %85 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %89 = arith.cmpi ugt, %88, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %89 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %71, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %60, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %77 = arith.addi %68, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %61 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%78, %79, %60) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %77, %60 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %68, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %83 = arith.addi %33, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %84 = arith.addi %37, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %85 = arith.addi %33, %c127_i256 : i256 loc(#loc1) +// CHECK-NEXT: %86 = arith.cmpi sge, %85, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %86 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %90 = arith.addi %30, %88 : i256 loc(#loc1) -// CHECK-NEXT: %91 = arith.addi %90, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %92 = arith.cmpi sge, %91, %1 : i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %89 = arith.addi %88, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %90 = arith.cmpi ugt, %89, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = arith.cmpi ult, %89, %88 : i256 loc(#loc1) +// CHECK-NEXT: %92 = arith.ori %90, %91 : i1 loc(#loc1) // CHECK-NEXT: scf.if %92 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%143, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %89, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %33, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = arith.cmpi ugt, %94, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %95 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %93 = llvm.inttoptr %90 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %95 = arith.addi %90, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %96 = arith.muli %94, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %97 = arith.addi %95, %96 : i256 loc(#loc1) -// CHECK-NEXT: %98 = arith.cmpi ugt, %97, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %98 { -// CHECK-NEXT: %124 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %125, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %127 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %125, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %125, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %132 = llvm.inttoptr %131 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %133 = arith.addi %125, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %134 = llvm.inttoptr %133 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%135, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %96:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %88, %arg2 = %83) -> (i256, i256) { +// CHECK-NEXT: %141 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %142, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %144, %145 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %97 = llvm.inttoptr %84 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %88, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %98 = arith.addi %33, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %99 = arith.addi %37, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %100 = llvm.inttoptr %98 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %101 = llvm.load %100 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %102 = arith.cmpi ugt, %101, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %102 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %99 = arith.muli %94, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %100 = arith.cmpi ugt, %94, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %100 { -// CHECK-NEXT: %124 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %124 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %125 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %125 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%126, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %103 = arith.addi %33, %101 : i256 loc(#loc1) +// CHECK-NEXT: %104 = arith.addi %103, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %105 = arith.cmpi sge, %104, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %105 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %101 = arith.addi %99, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %102 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %103 = llvm.load %102 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %104 = arith.addi %103, %101 : i256 loc(#loc1) -// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %104, %105 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %106 = llvm.inttoptr %103 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %94, %106 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %107 = arith.addi %103, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %108 = arith.index_castui %94 : i256 to index loc(#loc1) -// CHECK-NEXT: %109:2 = scf.for %arg0 = %c0 to %108 step %c1 iter_args(%arg1 = %107, %arg2 = %95) -> (i256, i256) { -// CHECK-NEXT: %124 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %125 = llvm.load %124 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %125, %126 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %128 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %127, %128 : i256, i256 loc(#loc1) +// CHECK-NEXT: %106 = llvm.inttoptr %103 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %107 = llvm.load %106 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %108 = arith.addi %103, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %109 = arith.muli %107, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %110 = arith.addi %108, %109 : i256 loc(#loc1) +// CHECK-NEXT: %111 = arith.cmpi ugt, %110, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %111 { +// CHECK-NEXT: %141 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %142, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %146 = arith.addi %142, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %142, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = llvm.inttoptr %148 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %149 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %142, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %151 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %110 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %103, %110 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %111 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %34, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %112 = arith.addi %13, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %113 = arith.addi %19, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %114 = llvm.inttoptr %112 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %115 = llvm.load %114 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %116 = llvm.inttoptr %113 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %115, %116 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %117:2 = func.call @mem_nested_71(%19) : (i256) -> (i256, i256) loc(#loc1) -// CHECK-NEXT: %118 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %119 = llvm.load %118 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %120 = llvm.inttoptr %119 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %117#0, %120 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %121 = arith.addi %119, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %122 = llvm.inttoptr %121 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %117#1, %122 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %119 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%123, %c64_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %112 = arith.muli %107, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %113 = arith.cmpi ugt, %107, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %113 { +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%143, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %114 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %115 = llvm.load %114 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %116 = arith.addi %112, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %117 = arith.andi %116, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %118 = arith.addi %115, %117 : i256 loc(#loc1) +// CHECK-NEXT: %119 = arith.cmpi ugt, %118, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %120 = arith.cmpi ult, %118, %115 : i256 loc(#loc1) +// CHECK-NEXT: %121 = arith.ori %119, %120 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %121 { +// CHECK-NEXT: %141 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %141 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %142 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%143, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %122 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %118, %122 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %123 = llvm.inttoptr %115 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %107, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %124 = arith.addi %115, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %125 = arith.index_castui %107 : i256 to index loc(#loc1) +// CHECK-NEXT: %126:2 = scf.for %arg0 = %c0 to %125 step %c1 iter_args(%arg1 = %124, %arg2 = %108) -> (i256, i256) { +// CHECK-NEXT: %141 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %142, %143 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %145 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %144, %145 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %127 = llvm.inttoptr %99 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %115, %127 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %128 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %37, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %129 = arith.addi %13, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %130 = arith.addi %19, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %129 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %132, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134:2 = func.call @mem_nested_71(%19) : (i256) -> (i256, i256) loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = llvm.load %135 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %134#0, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %136, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %134#1, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c64_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } diff --git a/test/lit/mlirCodegen/EVM/abi-encode-array-head-size.sol b/test/lit/mlirCodegen/EVM/abi-encode-array-head-size.sol index ac5f30210..3bd5e7558 100644 --- a/test/lit/mlirCodegen/EVM/abi-encode-array-head-size.sol +++ b/test/lit/mlirCodegen/EVM/abi-encode-array-head-size.sol @@ -18,6 +18,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -26,8 +33,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_35"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -35,22 +42,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_35() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_35_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_35_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_35_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_35_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -62,14 +83,15 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -103,63 +125,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -169,135 +191,163 @@ contract C { // CHECK-NEXT: %22 = arith.addi %20, %21 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.muli %19, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.index_castui %19 : i256 to index loc(#loc1) -// CHECK-NEXT: %34:2 = scf.for %arg0 = %c0 to %33 step %c1 iter_args(%arg1 = %32, %arg2 = %20) -> (i256, i256) { -// CHECK-NEXT: %52 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %53 = arith.cmpi sge, %52, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %53 { -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.index_castui %19 : i256 to index loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg0 = %c0 to %37 step %c1 iter_args(%arg1 = %36, %arg2 = %20) -> (i256, i256) { +// CHECK-NEXT: %58 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %59 = arith.cmpi sge, %58, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %59 { +// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = arith.addi %74, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %83 = llvm.inttoptr %82 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%84, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = arith.addi %55, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %57 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %56, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %59 = arith.cmpi ugt, %58, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %59 { -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %61, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %63 = arith.cmpi ugt, %62, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = arith.cmpi ult, %62, %61 : i256 loc(#loc1) +// CHECK-NEXT: %65 = arith.ori %63, %64 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %65 { +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%75, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %62, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = arith.cmpi ugt, %67, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %68 { +// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = arith.addi %74, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %83 = llvm.inttoptr %82 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%84, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %60:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %55, %arg5 = %arg2) -> (i256, i256) { -// CHECK-NEXT: %64 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %65, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %67, %68 : i256, i256 loc(#loc1) +// CHECK-NEXT: %69:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %61, %arg5 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %73 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %74, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %76, %77 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %61 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %55, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %62 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %62, %63 : i256, i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %61, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %72 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %71, %72 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = func.call @enc1_16(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %37, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%44, %45, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %42, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %42, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %48 = arith.andi %47, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %40, %48 : i256 loc(#loc1) -// CHECK-NEXT: %50 = arith.subi %49, %37 : i256 loc(#loc1) -// CHECK-NEXT: %51 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%51, %50) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = func.call @enc1_16(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %41, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %41, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %39, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%48, %49, %46) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %44, %46 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %46, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %46, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.andi %53, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %44, %54 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.subi %55, %41 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %56) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -305,63 +355,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -371,193 +421,233 @@ contract C { // CHECK-NEXT: %22 = arith.addi %20, %21 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.muli %19, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.index_castui %19 : i256 to index loc(#loc1) -// CHECK-NEXT: %34:2 = scf.for %arg0 = %c0 to %33 step %c1 iter_args(%arg1 = %32, %arg2 = %20) -> (i256, i256) { -// CHECK-NEXT: %52 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %53 = arith.cmpi sge, %52, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %53 { -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.index_castui %19 : i256 to index loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg0 = %c0 to %37 step %c1 iter_args(%arg1 = %36, %arg2 = %20) -> (i256, i256) { +// CHECK-NEXT: %58 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %59 = arith.cmpi sge, %58, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %59 { +// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = arith.addi %74, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %83 = llvm.inttoptr %82 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%84, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = arith.addi %55, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %57 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %56, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %arg2, %c128_i256 : i256 loc(#loc1) -// CHECK-NEXT: %59 = arith.cmpi ugt, %58, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %59 { -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %61, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %63 = arith.cmpi ugt, %62, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = arith.cmpi ult, %62, %61 : i256 loc(#loc1) +// CHECK-NEXT: %65 = arith.ori %63, %64 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %65 { +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%75, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %60:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %55, %arg5 = %arg2) -> (i256, i256) { -// CHECK-NEXT: %64 = arith.addi %arg5, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %65 = arith.cmpi sge, %64, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %65 { -// CHECK-NEXT: %76 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = llvm.load %76 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %77, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %77, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = arith.addi %77, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %85 = arith.addi %77, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %86 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %87 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%87, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %62, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %arg2, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = arith.cmpi ugt, %67, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %68 { +// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = arith.addi %74, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %83 = llvm.inttoptr %82 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%84, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %69:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %61, %arg5 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %73 = arith.addi %arg5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %74 = arith.cmpi sge, %73, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %74 { +// CHECK-NEXT: %88 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %89 = llvm.load %88 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %90 = llvm.inttoptr %89 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %91 = arith.addi %89, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %92 = llvm.inttoptr %91 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %92 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %93 = arith.addi %89, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %94 = llvm.inttoptr %93 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %94 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %95 = arith.addi %89, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %95 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %96 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %97 = arith.addi %89, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %98 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %98 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %99 = llvm.inttoptr %89 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%99, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = llvm.load %75 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %77 = arith.addi %76, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %78 = arith.cmpi ugt, %77, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %79 = arith.cmpi ult, %77, %76 : i256 loc(#loc1) +// CHECK-NEXT: %80 = arith.ori %78, %79 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %80 { +// CHECK-NEXT: %88 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %88 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %89 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %90 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%90, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %68 = arith.addi %67, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %69 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %68, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %70 = arith.addi %arg5, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %71 = arith.cmpi ugt, %70, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %71 { -// CHECK-NEXT: %76 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = llvm.load %76 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %77, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %77, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = arith.addi %77, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %85 = arith.addi %77, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %86 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %87 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%87, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %77, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = arith.addi %arg5, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %83 = arith.cmpi ugt, %82, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %83 { +// CHECK-NEXT: %88 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %89 = llvm.load %88 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %90 = llvm.inttoptr %89 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %91 = arith.addi %89, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %92 = llvm.inttoptr %91 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %92 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %93 = arith.addi %89, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %94 = llvm.inttoptr %93 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %94 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %95 = arith.addi %89, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %95 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %96 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %97 = arith.addi %89, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %98 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %98 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %99 = llvm.inttoptr %89 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%99, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %72:2 = scf.for %arg6 = %c0 to %c2 step %c1 iter_args(%arg7 = %67, %arg8 = %arg5) -> (i256, i256) { -// CHECK-NEXT: %76 = llvm.inttoptr %arg8 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %77 = llvm.load %76 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %77, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %arg7, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = arith.addi %arg8, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %79, %80 : i256, i256 loc(#loc1) +// CHECK-NEXT: %84:2 = scf.for %arg6 = %c0 to %c2 step %c1 iter_args(%arg7 = %76, %arg8 = %arg5) -> (i256, i256) { +// CHECK-NEXT: %88 = llvm.inttoptr %arg8 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %89 = llvm.load %88 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %90 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %89, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %91 = arith.addi %arg7, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %arg8, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %91, %92 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %73 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %67, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %74 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %arg5, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %74, %75 : i256, i256 loc(#loc1) +// CHECK-NEXT: %85 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %76, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %87 = arith.addi %arg5, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %86, %87 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %61 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %55, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %62 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %arg2, %c128_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %62, %63 : i256, i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %61, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %72 = arith.addi %arg2, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %71, %72 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = func.call @enc2_34(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %37, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%44, %45, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %42, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %42, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %48 = arith.andi %47, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %40, %48 : i256 loc(#loc1) -// CHECK-NEXT: %50 = arith.subi %49, %37 : i256 loc(#loc1) -// CHECK-NEXT: %51 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%51, %50) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = func.call @enc2_34(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %41, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %41, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %39, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%48, %49, %46) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %44, %46 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %46, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %46, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.andi %53, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %44, %54 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.subi %55, %41 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %56) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -572,6 +662,14 @@ contract C { // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @enc2_34(%arg0: i256 loc({{.*}}:7:16)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) @@ -599,39 +697,63 @@ contract C { // CHECK-NEXT: %14 = arith.muli %9, %c128_i256 : i256 loc(#loc5) // CHECK-NEXT: %15 = arith.addi %12, %14 : i256 loc(#loc5) // CHECK-NEXT: %16:3 = scf.for %arg1 = %c0 to %11 step %c1 iter_args(%arg2 = %12, %arg3 = %13, %arg4 = %15) -> (i256, i256, i256) { -// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %22 = arith.addi %arg2, %c128_i256 : i256 loc(#loc5) -// CHECK-NEXT: %23:3 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg2, %arg7 = %21, %arg8 = %22) -> (i256, i256, i256) { -// CHECK-NEXT: %26 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %28 = arith.addi %arg6, %c64_i256 : i256 loc(#loc5) -// CHECK-NEXT: %29:2 = scf.for %arg9 = %c0 to %c2 step %c1 iter_args(%arg10 = %arg6, %arg11 = %27) -> (i256, i256) { -// CHECK-NEXT: %32 = llvm.inttoptr %arg11 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %34 = llvm.inttoptr %arg10 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %35 = arith.addi %arg10, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %36 = arith.addi %arg11, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.yield %35, %36 : i256, i256 loc(#loc5) +// CHECK-NEXT: %27 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %29 = arith.addi %arg2, %c128_i256 : i256 loc(#loc5) +// CHECK-NEXT: %30:3 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg2, %arg7 = %28, %arg8 = %29) -> (i256, i256, i256) { +// CHECK-NEXT: %33 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %35 = arith.addi %arg6, %c64_i256 : i256 loc(#loc5) +// CHECK-NEXT: %36:2 = scf.for %arg9 = %c0 to %c2 step %c1 iter_args(%arg10 = %arg6, %arg11 = %34) -> (i256, i256) { +// CHECK-NEXT: %39 = llvm.inttoptr %arg11 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %41 = llvm.inttoptr %arg10 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %42 = arith.addi %arg10, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %43 = arith.addi %arg11, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %42, %43 : i256, i256 loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %30 = arith.addi %arg6, %c64_i256 : i256 loc(#loc5) -// CHECK-NEXT: %31 = arith.addi %arg7, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.yield %30, %31, %28 : i256, i256, i256 loc(#loc5) +// CHECK-NEXT: %37 = arith.addi %arg6, %c64_i256 : i256 loc(#loc5) +// CHECK-NEXT: %38 = arith.addi %arg7, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %37, %38, %35 : i256, i256, i256 loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %24 = arith.addi %arg2, %c128_i256 : i256 loc(#loc5) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.yield %24, %25, %23#2 : i256, i256, i256 loc(#loc5) +// CHECK-NEXT: %31 = arith.addi %arg2, %c128_i256 : i256 loc(#loc5) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %31, %32, %30#2 : i256, i256, i256 loc(#loc5) // CHECK-NEXT: } loc(#loc5) // CHECK-NEXT: %17 = arith.subi %16#2, %4 : i256 loc(#loc5) // CHECK-NEXT: %18 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc5) // CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %16#2, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %19 = arith.subi %16#2, %3 : i256 loc(#loc5) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc5) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %22 = arith.addi %3, %21 : i256 loc(#loc5) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %3 : i256 loc(#loc5) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc5) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) // CHECK-NEXT: return %3 : i256 loc(#loc6) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: func.func @enc1_16(%arg0: i256 loc({{.*}}:3:16)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) @@ -658,27 +780,43 @@ contract C { // CHECK-NEXT: %14 = arith.muli %9, %c64_i256 : i256 loc(#loc10) // CHECK-NEXT: %15 = arith.addi %12, %14 : i256 loc(#loc10) // CHECK-NEXT: %16:3 = scf.for %arg1 = %c0 to %11 step %c1 iter_args(%arg2 = %12, %arg3 = %13, %arg4 = %15) -> (i256, i256, i256) { -// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %22 = arith.addi %arg2, %c64_i256 : i256 loc(#loc10) -// CHECK-NEXT: %23:2 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg2, %arg7 = %21) -> (i256, i256) { -// CHECK-NEXT: %26 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %28 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %29 = arith.addi %arg6, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %30 = arith.addi %arg7, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.yield %29, %30 : i256, i256 loc(#loc10) +// CHECK-NEXT: %27 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %29 = arith.addi %arg2, %c64_i256 : i256 loc(#loc10) +// CHECK-NEXT: %30:2 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg2, %arg7 = %28) -> (i256, i256) { +// CHECK-NEXT: %33 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %35 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %36 = arith.addi %arg6, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %37 = arith.addi %arg7, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.yield %36, %37 : i256, i256 loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %24 = arith.addi %arg2, %c64_i256 : i256 loc(#loc10) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.yield %24, %25, %22 : i256, i256, i256 loc(#loc10) +// CHECK-NEXT: %31 = arith.addi %arg2, %c64_i256 : i256 loc(#loc10) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.yield %31, %32, %29 : i256, i256, i256 loc(#loc10) // CHECK-NEXT: } loc(#loc10) // CHECK-NEXT: %17 = arith.subi %16#2, %4 : i256 loc(#loc10) // CHECK-NEXT: %18 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc10) // CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %16#2, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %19 = arith.subi %16#2, %3 : i256 loc(#loc10) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc10) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %22 = arith.addi %3, %21 : i256 loc(#loc10) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %3 : i256 loc(#loc10) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc10) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) // CHECK-NEXT: return %3 : i256 loc(#loc11) // CHECK-NEXT: } loc(#loc7) // CHECK-NEXT: } loc(#loc1) diff --git a/test/lit/mlirCodegen/EVM/abi-encode-calldata-access.sol b/test/lit/mlirCodegen/EVM/abi-encode-calldata-access.sol new file mode 100644 index 000000000..0a0d07077 --- /dev/null +++ b/test/lit/mlirCodegen/EVM/abi-encode-calldata-access.sol @@ -0,0 +1,1080 @@ +// RUN: solc --mlir-action=print-std-mlir --mlir-target=evm --mmlir --mlir-print-debuginfo %s | FileCheck %s + +contract C { + function array_encode(uint256[][2] calldata x) external pure returns (bytes memory) { + return abi.encode(x); + } + + function array_dyn_encode(uint256[][] calldata x) external pure returns (bytes memory) { + return abi.encode(x); + } + + function array_nested_encode(uint256[][2][] calldata x) external pure returns (bytes memory) { + return abi.encode(x); + } +} +// NOTE: Assertions have been autogenerated by test/updFileCheckTest.py +// CHECK: #Osaka = #sol +// CHECK-NEXT: #loc3 = loc({{.*}}:11:31) +// CHECK-NEXT: #loc8 = loc({{.*}}:7:28) +// CHECK-NEXT: #loc13 = loc({{.*}}:3:24) +// CHECK-NEXT: module @C_49 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %0 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %2 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %4 = "llvm.intrcall"() <{id = 4042 : i32, name = "evm.codesize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @C_49() : () -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_49_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @C_49() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: return loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: module @C_49_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) +// CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.mlir.undef : !llvm.struct<(i256, i256)> loc(#loc) +// CHECK-NEXT: %c51765758038840874448248112245855622722229435958027532839407121884968680161280_i256 = arith.constant 51765758038840874448248112245855622722229435958027532839407121884968680161280 : i256 loc(#loc) +// CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) +// CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) +// CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) +// CHECK-NEXT: %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256 = arith.constant 45888551966424197807937402689295079693071411769653575580334356259971920822272 : i256 loc(#loc) +// CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256 = arith.constant 29517451764962235613010368778373659638394623262010481748738546747006033225331 : i256 loc(#loc) +// CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) +// CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %1 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %2 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %3 = arith.cmpi uge, %2, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %3 { +// CHECK-NEXT: %5 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %7 = arith.shrui %6, %c224_i256 : i256 loc(#loc1) +// CHECK-NEXT: %8 = arith.trunci %7 : i256 to i32 loc(#loc1) +// CHECK-NEXT: scf.int_switch %8 : i32 +// CHECK-NEXT: case 440926352 { +// CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%38, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%38, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = arith.addi %39, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = arith.addi %39, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %39, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %39, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%49, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = arith.addi %14, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.cmpi ugt, %17, %2 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = arith.addi %39, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = arith.addi %39, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %39, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %39, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%49, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %19 = func.call @array_encode_16(%16) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.addi %21, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %21, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %19, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%28, %29, %26) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %24, %26 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %26, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %26, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.andi %33, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %35 = arith.addi %24, %34 : i256 loc(#loc1) +// CHECK-NEXT: %36 = arith.subi %35, %21 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%37, %36) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1255901874 { +// CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %14, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038840874448248112245855622722229435958027532839407121884968680161280_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %23 = arith.muli %20, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %21, %23 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %2 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.insertvalue %21, %0[0] : !llvm.struct<(i256, i256)> loc(#loc1) +// CHECK-NEXT: %27 = llvm.insertvalue %20, %26[1] : !llvm.struct<(i256, i256)> loc(#loc1) +// CHECK-NEXT: %28 = func.call @array_dyn_encode_31(%27) : (!llvm.struct<(i256, i256)>) -> i256 loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.addi %30, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %30, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %28, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%37, %38, %35) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %33, %35 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %35, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %35, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = arith.andi %42, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %33, %43 : i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.subi %44, %30 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %45) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1080530452 { +// CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %14, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038840874448248112245855622722229435958027532839407121884968680161280_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %23 = arith.muli %20, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %21, %23 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %2 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.insertvalue %21, %0[0] : !llvm.struct<(i256, i256)> loc(#loc1) +// CHECK-NEXT: %27 = llvm.insertvalue %20, %26[1] : !llvm.struct<(i256, i256)> loc(#loc1) +// CHECK-NEXT: %28 = func.call @array_nested_encode_48(%27) : (!llvm.struct<(i256, i256)>) -> i256 loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.addi %30, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %30, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %28, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%37, %38, %35) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %33, %35 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %35, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %35, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = arith.andi %42, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %33, %43 : i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.subi %44, %30 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %45) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: default { +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %4 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%4, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @array_nested_encode_48(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:11:31)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256 = arith.constant 46588223404076438002452388499589275425339095392816320687750512315683798253568 : i256 loc(#loc) +// CHECK-NEXT: %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256 = arith.constant 29517451765071250289932898678666425651196573092471976580941455186195129331566 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 = arith.constant 3618502788666131106986593281521497120414687020801267626233049500247285301247 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099523263123094306816 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099014633433810337792 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099231078946096545792 : i256 loc(#loc) +// CHECK-NEXT: %c30_i256 = arith.constant 30 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc3) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc3) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc3) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc4) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc5) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc5) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc5) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc5) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc5) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc5) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc5) +// CHECK-NEXT: %15:3 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12, %arg4 = %14) -> (i256, i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc5) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc5) +// CHECK-NEXT: %28 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc5) +// CHECK-NEXT: %29 = arith.subi %28, %12 : i256 loc(#loc5) +// CHECK-NEXT: %30 = arith.subi %29, %c63_i256 : i256 loc(#loc5) +// CHECK-NEXT: %31 = arith.cmpi sge, %27, %30 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %31 { +// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %42 = arith.addi %40, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %44 = arith.addi %40, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c30_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %46 = arith.addi %40, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %48 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%48, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %32 = arith.addi %12, %27 : i256 loc(#loc5) +// CHECK-NEXT: %33 = arith.subi %arg4, %11 : i256 loc(#loc5) +// CHECK-NEXT: %34 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %35 = arith.addi %arg4, %c64_i256 : i256 loc(#loc5) +// CHECK-NEXT: %36:3 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg4, %arg7 = %32, %arg8 = %35) -> (i256, i256, i256) { +// CHECK-NEXT: %39 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<2> loc(#loc5) +// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc5) +// CHECK-NEXT: %41 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc5) +// CHECK-NEXT: %42 = arith.subi %41, %32 : i256 loc(#loc5) +// CHECK-NEXT: %43 = arith.subi %42, %c31_i256 : i256 loc(#loc5) +// CHECK-NEXT: %44 = arith.cmpi sge, %40, %43 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %69 = arith.addi %67, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %71 = arith.addi %67, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c30_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %73 = arith.addi %67, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %75 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%75, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %45 = arith.addi %32, %40 : i256 loc(#loc5) +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<2> loc(#loc5) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc5) +// CHECK-NEXT: %48 = arith.addi %45, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %49 = arith.cmpi ugt, %47, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %49 { +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %69 = arith.addi %67, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %71 = arith.addi %67, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c30_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %73 = arith.addi %67, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %75 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%75, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %50 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc5) +// CHECK-NEXT: %51 = arith.muli %47, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %52 = arith.subi %50, %51 : i256 loc(#loc5) +// CHECK-NEXT: %53 = arith.cmpi sgt, %48, %52 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %53 { +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %69 = arith.addi %67, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %71 = arith.addi %67, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c30_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %73 = arith.addi %67, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %75 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%75, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %54 = arith.subi %arg8, %arg4 : i256 loc(#loc5) +// CHECK-NEXT: %55 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %54, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %56 = arith.cmpi ugt, %47, %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %56 { +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %69 = arith.addi %67, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %71 = arith.addi %67, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c33_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %73 = arith.addi %67, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %75 = arith.addi %67, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %77 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%77, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %57 = llvm.inttoptr %arg8 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %47, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %58 = arith.addi %arg8, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %59 = arith.muli %47, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %60 = arith.addi %58, %59 : i256 loc(#loc5) +// CHECK-NEXT: %61 = arith.muli %47, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %62 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %63 = llvm.inttoptr %48 : i256 to !llvm.ptr<2> loc(#loc5) +// CHECK-NEXT: "llvm.intr.memcpy"(%62, %63, %61) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc5) +// CHECK-NEXT: %64 = arith.addi %arg6, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %65 = arith.addi %arg7, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %64, %65, %60 : i256, i256, i256 loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %37 = arith.addi %arg2, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %38 = arith.addi %arg3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %37, %38, %36#2 : i256, i256, i256 loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %16 = arith.subi %15#2, %4 : i256 loc(#loc5) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %18 = arith.subi %15#2, %3 : i256 loc(#loc5) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc5) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc5) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc5) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc5) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: return %3 : i256 loc(#loc6) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: func.func @array_dyn_encode_31(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:7:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256 = arith.constant 46588223404076438002452388499589275425339095392816320687750512315683798253568 : i256 loc(#loc) +// CHECK-NEXT: %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256 = arith.constant 29517451765071250289932898678666425651196573092471976580941455186195129331566 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 = arith.constant 3618502788666131106986593281521497120414687020801267626233049500247285301247 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099523263123094306816 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099014633433810337792 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099231078946096545792 : i256 loc(#loc) +// CHECK-NEXT: %c30_i256 = arith.constant 30 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc8) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc8) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc8) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc9) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc10) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc10) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc10) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc10) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc10) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc10) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc10) +// CHECK-NEXT: %15:3 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12, %arg4 = %14) -> (i256, i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc10) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc10) +// CHECK-NEXT: %28 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc10) +// CHECK-NEXT: %29 = arith.subi %28, %12 : i256 loc(#loc10) +// CHECK-NEXT: %30 = arith.subi %29, %c31_i256 : i256 loc(#loc10) +// CHECK-NEXT: %31 = arith.cmpi sge, %27, %30 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %31 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c30_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %62 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%62, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %32 = arith.addi %12, %27 : i256 loc(#loc10) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<2> loc(#loc10) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc10) +// CHECK-NEXT: %35 = arith.addi %32, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %36 = arith.cmpi ugt, %34, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c30_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %62 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%62, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %37 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc10) +// CHECK-NEXT: %38 = arith.muli %34, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %39 = arith.subi %37, %38 : i256 loc(#loc10) +// CHECK-NEXT: %40 = arith.cmpi sgt, %35, %39 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %40 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c30_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %62 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%62, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %41 = arith.subi %arg4, %11 : i256 loc(#loc10) +// CHECK-NEXT: %42 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %41, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %43 = arith.cmpi ugt, %34, %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %43 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c33_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %44 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %34, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %45 = arith.addi %arg4, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %46 = arith.muli %34, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %47 = arith.addi %45, %46 : i256 loc(#loc10) +// CHECK-NEXT: %48 = arith.muli %34, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %49 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %50 = llvm.inttoptr %35 : i256 to !llvm.ptr<2> loc(#loc10) +// CHECK-NEXT: "llvm.intr.memcpy"(%49, %50, %48) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc10) +// CHECK-NEXT: %51 = arith.addi %arg2, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %52 = arith.addi %arg3, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.yield %51, %52, %47 : i256, i256, i256 loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %16 = arith.subi %15#2, %4 : i256 loc(#loc10) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %18 = arith.subi %15#2, %3 : i256 loc(#loc10) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc10) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc10) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc10) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc10) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: return %3 : i256 loc(#loc11) +// CHECK-NEXT: } loc(#loc7) +// CHECK-NEXT: func.func @array_encode_16(%arg0: i256 loc({{.*}}:3:24)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256 = arith.constant 46588223404076438002452388499589275425339095392816320687750512315683798253568 : i256 loc(#loc) +// CHECK-NEXT: %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256 = arith.constant 29517451765071250289932898678666425651196573092471976580941455186195129331566 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 = arith.constant 3618502788666131106986593281521497120414687020801267626233049500247285301247 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099523263123094306816 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099014633433810337792 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099231078946096545792 : i256 loc(#loc) +// CHECK-NEXT: %c30_i256 = arith.constant 30 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc13) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc13) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc13) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc14) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc15) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc15) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %8 = arith.addi %3, %c128_i256 : i256 loc(#loc15) +// CHECK-NEXT: %9:3 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %5, %arg3 = %1, %arg4 = %8) -> (i256, i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc15) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc15) +// CHECK-NEXT: %22 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc15) +// CHECK-NEXT: %23 = arith.subi %22, %1 : i256 loc(#loc15) +// CHECK-NEXT: %24 = arith.subi %23, %c31_i256 : i256 loc(#loc15) +// CHECK-NEXT: %25 = arith.cmpi sge, %21, %24 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c30_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %56 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%56, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %26 = arith.addi %1, %21 : i256 loc(#loc15) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<2> loc(#loc15) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc15) +// CHECK-NEXT: %29 = arith.addi %26, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %30 = arith.cmpi ugt, %28, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c30_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %56 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%56, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %31 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc15) +// CHECK-NEXT: %32 = arith.muli %28, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %33 = arith.subi %31, %32 : i256 loc(#loc15) +// CHECK-NEXT: %34 = arith.cmpi sgt, %29, %33 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c30_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %56 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%56, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %35 = arith.subi %arg4, %5 : i256 loc(#loc15) +// CHECK-NEXT: %36 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %37 = arith.cmpi ugt, %28, %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %37 { +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c33_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %38 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %28, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %39 = arith.addi %arg4, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %40 = arith.muli %28, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %41 = arith.addi %39, %40 : i256 loc(#loc15) +// CHECK-NEXT: %42 = arith.muli %28, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %43 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %44 = llvm.inttoptr %29 : i256 to !llvm.ptr<2> loc(#loc15) +// CHECK-NEXT: "llvm.intr.memcpy"(%43, %44, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc15) +// CHECK-NEXT: %45 = arith.addi %arg2, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %46 = arith.addi %arg3, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.yield %45, %46, %41 : i256, i256, i256 loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %10 = arith.subi %9#2, %4 : i256 loc(#loc15) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %12 = arith.subi %9#2, %3 : i256 loc(#loc15) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc15) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc15) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc15) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc15) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: return %3 : i256 loc(#loc16) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: #loc = loc(unknown) +// CHECK-NEXT: #loc1 = loc({{.*}}:2:0) +// CHECK-NEXT: #loc2 = loc({{.*}}:11:2) +// CHECK-NEXT: #loc4 = loc({{.*}}:12:22) +// CHECK-NEXT: #loc5 = loc({{.*}}:12:11) +// CHECK-NEXT: #loc6 = loc({{.*}}:12:4) +// CHECK-NEXT: #loc7 = loc({{.*}}:7:2) +// CHECK-NEXT: #loc9 = loc({{.*}}:8:22) +// CHECK-NEXT: #loc10 = loc({{.*}}:8:11) +// CHECK-NEXT: #loc11 = loc({{.*}}:8:4) +// CHECK-NEXT: #loc12 = loc({{.*}}:3:2) +// CHECK-NEXT: #loc14 = loc({{.*}}:4:22) +// CHECK-NEXT: #loc15 = loc({{.*}}:4:11) +// CHECK-NEXT: #loc16 = loc({{.*}}:4:4) +// CHECK-EMPTY: diff --git a/test/lit/mlirCodegen/EVM/abi-encode-packed-nested-fixed-array.sol b/test/lit/mlirCodegen/EVM/abi-encode-packed-nested-fixed-array.sol new file mode 100644 index 000000000..e6e65e5e2 --- /dev/null +++ b/test/lit/mlirCodegen/EVM/abi-encode-packed-nested-fixed-array.sol @@ -0,0 +1,1500 @@ +// RUN: solc --mlir-action=print-std-mlir --mlir-target=evm --mmlir --mlir-print-debuginfo %s | FileCheck %s + +contract C { + uint16[2][3] nestedU16; + uint256[4][5][4] nestedU256; + + function ep_nested_u16_memory(uint16[2][3] memory x) public pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u16_calldata(uint16[2][3] calldata x) external pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u16_storage() external view returns (bytes memory) { + return abi.encodePacked(nestedU16); + } + + function ep_nested_u256_memory(uint256[4][5][4] memory x) public pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u256_calldata(uint256[4][5][4] calldata x) external pure returns (bytes memory) { + return abi.encodePacked(x); + } + + function ep_nested_u256_storage() external view returns (bytes memory) { + return abi.encodePacked(nestedU256); + } + + function ep_nested_addr_memory(address[2][2] memory x) public pure returns (bytes memory) { + return abi.encodePacked(x); + } +} +// NOTE: Assertions have been autogenerated by test/updFileCheckTest.py +// CHECK: #Osaka = #sol +// CHECK-NEXT: #loc3 = loc({{.*}}:30:33) +// CHECK-NEXT: #loc12 = loc({{.*}}:22:35) +// CHECK-NEXT: #loc17 = loc({{.*}}:18:33) +// CHECK-NEXT: #loc25 = loc({{.*}}:10:34) +// CHECK-NEXT: #loc30 = loc({{.*}}:6:32) +// CHECK-NEXT: #loop_unroll = #llvm.loop_unroll +// CHECK-NEXT: #loop_annotation = #llvm.loop_annotation +// CHECK-NEXT: module @C_126 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %0 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %2 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_126"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %4 = "llvm.intrcall"() <{id = 4042 : i32, name = "evm.codesize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @C_126() : () -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_126_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_126_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @C_126() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: return loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: module @C_126_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c2564_i256 = arith.constant 2564 : i256 loc(#loc) +// CHECK-NEXT: %c196_i256 = arith.constant 196 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c640_i256 = arith.constant 640 : i256 loc(#loc) +// CHECK-NEXT: %c5 = arith.constant 5 : index loc(#loc) +// CHECK-NEXT: %c4 = arith.constant 4 : index loc(#loc) +// CHECK-NEXT: %c2560_i256 = arith.constant 2560 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) +// CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) +// CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) +// CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) +// CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %0 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %2 = arith.cmpi uge, %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %2 { +// CHECK-NEXT: %4 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %6 = arith.shrui %5, %c224_i256 : i256 loc(#loc1) +// CHECK-NEXT: %7 = arith.trunci %6 : i256 to i32 loc(#loc1) +// CHECK-NEXT: scf.int_switch %7 : i32 +// CHECK-NEXT: case 1436198889 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi slt, %10, %c192_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi sle, %1, %c35_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %14, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = arith.cmpi ult, %1, %c196_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %20 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %21:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %14, %arg2 = %c4_i256) -> (i256, i256) { +// CHECK-NEXT: %41 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.cmpi sge, %41, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %42 { +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %44, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = arith.cmpi ugt, %45, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.cmpi ult, %45, %44 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.ori %46, %47 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %56 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %45, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.cmpi ugt, %50, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %51 { +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %52:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %44, %arg5 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %56 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.trunci %57 : i256 to i16 loc(#loc1) +// CHECK-NEXT: %59 = arith.extui %58 : i16 to i256 loc(#loc1) +// CHECK-NEXT: %60 = arith.cmpi ne, %57, %59 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %60 { +// CHECK-NEXT: %65 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%65, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %61 = arith.extui %58 : i16 to i256 loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %61, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %63, %64 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %44, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %54, %55 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %22 = func.call @ep_nested_u16_memory_31(%14) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.addi %24, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %24, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %22, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%31, %32, %29) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %29, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %29, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.andi %36, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %38 = arith.addi %27, %37 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.subi %38, %24 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%40, %39) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1537333153 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi slt, %10, %c192_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %1, %c196_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = arith.addi %33, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %37 = arith.addi %33, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %33, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = arith.addi %33, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%43, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = func.call @ep_nested_u16_calldata_48(%c4_i256) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %16 = arith.addi %15, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %15, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %13, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%22, %23, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %18, %20 : i256 loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %20, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.andi %27, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %18, %28 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.subi %29, %15 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%31, %30) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 918009009 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_nested_u16_storage_59() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 115295362 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi slt, %10, %c2560_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi sle, %1, %c35_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %14, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = arith.cmpi ult, %1, %c2564_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %20 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %21:2 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %14, %arg2 = %c4_i256) -> (i256, i256) { +// CHECK-NEXT: %41 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.cmpi sge, %41, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %42 { +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %44, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = arith.cmpi ugt, %45, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.cmpi ult, %45, %44 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.ori %46, %47 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %56 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %45, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %arg2, %c640_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.cmpi ugt, %50, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %51 { +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %52:2 = scf.for %arg3 = %c0 to %c5 step %c1 iter_args(%arg4 = %44, %arg5 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %56 = arith.addi %arg5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = arith.cmpi sge, %56, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %57 { +// CHECK-NEXT: %71 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = arith.addi %72, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %72, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = arith.addi %72, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %72, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%82, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %60 = arith.addi %59, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %61 = arith.cmpi ugt, %60, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.cmpi ult, %60, %59 : i256 loc(#loc1) +// CHECK-NEXT: %63 = arith.ori %61, %62 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %63 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %60, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %arg5, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.cmpi ugt, %65, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %66 { +// CHECK-NEXT: %71 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = arith.addi %72, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %72, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = arith.addi %72, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %72, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%82, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %67:2 = scf.for %arg6 = %c0 to %c4 step %c1 iter_args(%arg7 = %59, %arg8 = %arg5) -> (i256, i256) { +// CHECK-NEXT: %71 = llvm.inttoptr %arg8 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %73 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %72, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = arith.addi %arg7, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %75 = arith.addi %arg8, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %74, %75 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %59, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = arith.addi %arg5, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %69, %70 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %44, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %arg2, %c640_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %54, %55 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %22 = func.call @ep_nested_u256_memory_78(%14) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.addi %24, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %24, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %22, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%31, %32, %29) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %29, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %29, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.andi %36, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %38 = arith.addi %27, %37 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.subi %38, %24 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%40, %39) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -60867908 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi slt, %10, %c2560_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %1, %c2564_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = arith.addi %33, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %37 = arith.addi %33, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %33, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = arith.addi %33, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%43, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = func.call @ep_nested_u256_calldata_97(%c4_i256) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %16 = arith.addi %15, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %15, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %13, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%22, %23, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %18, %20 : i256 loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %20, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.andi %27, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %18, %28 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.subi %29, %15 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%31, %30) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1062193926 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_nested_u256_storage_108() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -45025673 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi slt, %10, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi sle, %1, %c35_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %14, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = arith.cmpi ult, %1, %c132_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %20 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %21:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %14, %arg2 = %c4_i256) -> (i256, i256) { +// CHECK-NEXT: %41 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.cmpi sge, %41, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %42 { +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %44, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = arith.cmpi ugt, %45, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.cmpi ult, %45, %44 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.ori %46, %47 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %56 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %45, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.cmpi ugt, %50, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %51 { +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %52:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %44, %arg5 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %56 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.andi %57, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc1) +// CHECK-NEXT: %59 = arith.cmpi ne, %57, %58 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %59 { +// CHECK-NEXT: %63 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%63, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %58, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %61, %62 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %44, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %54, %55 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %22 = func.call @ep_nested_addr_memory_125(%14) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.addi %24, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %24, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %22, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%31, %32, %29) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %29, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %29, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.andi %36, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %38 = arith.addi %27, %37 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.subi %38, %24 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%40, %39) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: default { +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%3, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @ep_nested_addr_memory_125(%arg0: i256 loc({{.*}}:30:33)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc3) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc3) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc3) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc4) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %5 = arith.addi %3, %c160_i256 : i256 loc(#loc5) +// CHECK-NEXT: %6:3 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %4, %arg3 = %1, %arg4 = %5) -> (i256, i256, i256) { +// CHECK-NEXT: %17 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %19 = arith.addi %arg2, %c64_i256 : i256 loc(#loc5) +// CHECK-NEXT: %20:2 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg2, %arg7 = %18) -> (i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %25 = arith.andi %24, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc5) +// CHECK-NEXT: %26 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %27 = arith.addi %arg6, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %28 = arith.addi %arg7, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %27, %28 : i256, i256 loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %21 = arith.addi %arg2, %c64_i256 : i256 loc(#loc5) +// CHECK-NEXT: %22 = arith.addi %arg3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %21, %22, %19 : i256, i256, i256 loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %7 = arith.subi %6#2, %4 : i256 loc(#loc5) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %9 = arith.subi %6#2, %3 : i256 loc(#loc5) +// CHECK-NEXT: %10 = arith.addi %9, %c31_i256 : i256 loc(#loc5) +// CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %12 = arith.addi %3, %11 : i256 loc(#loc5) +// CHECK-NEXT: %13 = arith.cmpi ugt, %12, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: %14 = arith.cmpi ult, %12, %3 : i256 loc(#loc5) +// CHECK-NEXT: %15 = arith.ori %13, %14 : i1 loc(#loc5) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %12, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: return %3 : i256 loc(#loc6) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: func.func @ep_nested_u256_storage_108() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c2592_i256 = arith.constant 2592 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c5 = arith.constant 5 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c20_i256 = arith.constant 20 : i256 loc(#loc) +// CHECK-NEXT: %c640_i256 = arith.constant 640 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c4 = arith.constant 4 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 loc(#loc8) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc9) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc9) +// CHECK-NEXT: %3 = arith.addi %1, %c2592_i256 : i256 loc(#loc9) +// CHECK-NEXT: %4:3 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %2, %arg2 = %c3_i256, %arg3 = %3) -> (i256, i256, i256) { +// CHECK-NEXT: %15 = arith.addi %arg1, %c640_i256 : i256 loc(#loc9) +// CHECK-NEXT: %16:3 = scf.for %arg4 = %c0 to %c5 step %c1 iter_args(%arg5 = %arg1, %arg6 = %arg2, %arg7 = %15) -> (i256, i256, i256) { +// CHECK-NEXT: %19 = arith.addi %arg5, %c128_i256 : i256 loc(#loc9) +// CHECK-NEXT: %20:2 = scf.for %arg8 = %c0 to %c4 step %c1 iter_args(%arg9 = %arg5, %arg10 = %arg6) -> (i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg10 : i256 to !llvm.ptr<5> loc(#loc9) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc9) +// CHECK-NEXT: %25 = llvm.inttoptr %arg9 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %26 = arith.addi %arg9, %c32_i256 : i256 loc(#loc9) +// CHECK-NEXT: %27 = arith.addi %arg10, %c1_i256 : i256 loc(#loc9) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc9) +// CHECK-NEXT: } loc(#loc9) +// CHECK-NEXT: %21 = arith.addi %arg5, %c128_i256 : i256 loc(#loc9) +// CHECK-NEXT: %22 = arith.addi %arg6, %c4_i256 : i256 loc(#loc9) +// CHECK-NEXT: scf.yield %21, %22, %19 : i256, i256, i256 loc(#loc9) +// CHECK-NEXT: } loc(#loc9) +// CHECK-NEXT: %17 = arith.addi %arg1, %c640_i256 : i256 loc(#loc9) +// CHECK-NEXT: %18 = arith.addi %arg2, %c20_i256 : i256 loc(#loc9) +// CHECK-NEXT: scf.yield %17, %18, %16#2 : i256, i256, i256 loc(#loc9) +// CHECK-NEXT: } loc(#loc9) +// CHECK-NEXT: %5 = arith.subi %4#2, %2 : i256 loc(#loc9) +// CHECK-NEXT: %6 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %7 = arith.subi %4#2, %1 : i256 loc(#loc9) +// CHECK-NEXT: %8 = arith.addi %7, %c31_i256 : i256 loc(#loc9) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc9) +// CHECK-NEXT: %10 = arith.addi %1, %9 : i256 loc(#loc9) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc9) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %1 : i256 loc(#loc9) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc9) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc9) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc9) +// CHECK-NEXT: } loc(#loc9) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: return %1 : i256 loc(#loc10) +// CHECK-NEXT: } loc(#loc7) +// CHECK-NEXT: func.func @ep_nested_u256_calldata_97(%arg0: i256 loc({{.*}}:22:35)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c2592_i256 = arith.constant 2592 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c5 = arith.constant 5 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c640_i256 = arith.constant 640 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c4 = arith.constant 4 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc12) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc12) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc12) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc13) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc14) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc14) +// CHECK-NEXT: %5 = arith.addi %3, %c2592_i256 : i256 loc(#loc14) +// CHECK-NEXT: %6:3 = scf.for %arg1 = %c0 to %c4 step %c1 iter_args(%arg2 = %4, %arg3 = %1, %arg4 = %5) -> (i256, i256, i256) { +// CHECK-NEXT: %17 = arith.addi %arg2, %c640_i256 : i256 loc(#loc14) +// CHECK-NEXT: %18:3 = scf.for %arg5 = %c0 to %c5 step %c1 iter_args(%arg6 = %arg2, %arg7 = %arg3, %arg8 = %17) -> (i256, i256, i256) { +// CHECK-NEXT: %21 = arith.addi %arg6, %c128_i256 : i256 loc(#loc14) +// CHECK-NEXT: %22 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %23 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<2> loc(#loc14) +// CHECK-NEXT: "llvm.intr.memcpy"(%22, %23, %c128_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc14) +// CHECK-NEXT: %24 = arith.addi %arg6, %c128_i256 : i256 loc(#loc14) +// CHECK-NEXT: %25 = arith.addi %arg7, %c128_i256 : i256 loc(#loc14) +// CHECK-NEXT: scf.yield %24, %25, %21 : i256, i256, i256 loc(#loc14) +// CHECK-NEXT: } loc(#loc14) +// CHECK-NEXT: %19 = arith.addi %arg2, %c640_i256 : i256 loc(#loc14) +// CHECK-NEXT: %20 = arith.addi %arg3, %c640_i256 : i256 loc(#loc14) +// CHECK-NEXT: scf.yield %19, %20, %18#2 : i256, i256, i256 loc(#loc14) +// CHECK-NEXT: } loc(#loc14) +// CHECK-NEXT: %7 = arith.subi %6#2, %4 : i256 loc(#loc14) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %9 = arith.subi %6#2, %3 : i256 loc(#loc14) +// CHECK-NEXT: %10 = arith.addi %9, %c31_i256 : i256 loc(#loc14) +// CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc14) +// CHECK-NEXT: %12 = arith.addi %3, %11 : i256 loc(#loc14) +// CHECK-NEXT: %13 = arith.cmpi ugt, %12, %c18446744073709551615_i256 : i256 loc(#loc14) +// CHECK-NEXT: %14 = arith.cmpi ult, %12, %3 : i256 loc(#loc14) +// CHECK-NEXT: %15 = arith.ori %13, %14 : i1 loc(#loc14) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc14) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc14) +// CHECK-NEXT: } loc(#loc14) +// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %12, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: return %3 : i256 loc(#loc15) +// CHECK-NEXT: } loc(#loc11) +// CHECK-NEXT: func.func @ep_nested_u256_memory_78(%arg0: i256 loc({{.*}}:18:33)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c2592_i256 = arith.constant 2592 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c5 = arith.constant 5 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c640_i256 = arith.constant 640 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c4 = arith.constant 4 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc17) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc17) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc17) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc18) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc19) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %5 = arith.addi %3, %c2592_i256 : i256 loc(#loc19) +// CHECK-NEXT: %6:3 = scf.for %arg1 = %c0 to %c4 step %c1 iter_args(%arg2 = %4, %arg3 = %1, %arg4 = %5) -> (i256, i256, i256) { +// CHECK-NEXT: %17 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc19) +// CHECK-NEXT: %19 = arith.addi %arg2, %c640_i256 : i256 loc(#loc19) +// CHECK-NEXT: %20:3 = scf.for %arg5 = %c0 to %c5 step %c1 iter_args(%arg6 = %arg2, %arg7 = %18, %arg8 = %19) -> (i256, i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc19) +// CHECK-NEXT: %25 = arith.addi %arg6, %c128_i256 : i256 loc(#loc19) +// CHECK-NEXT: %26:2 = scf.for %arg9 = %c0 to %c4 step %c1 iter_args(%arg10 = %arg6, %arg11 = %24) -> (i256, i256) { +// CHECK-NEXT: %29 = llvm.inttoptr %arg11 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc19) +// CHECK-NEXT: %31 = llvm.inttoptr %arg10 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %32 = arith.addi %arg10, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %33 = arith.addi %arg11, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %27 = arith.addi %arg6, %c128_i256 : i256 loc(#loc19) +// CHECK-NEXT: %28 = arith.addi %arg7, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: scf.yield %27, %28, %25 : i256, i256, i256 loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %21 = arith.addi %arg2, %c640_i256 : i256 loc(#loc19) +// CHECK-NEXT: %22 = arith.addi %arg3, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: scf.yield %21, %22, %20#2 : i256, i256, i256 loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %7 = arith.subi %6#2, %4 : i256 loc(#loc19) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %9 = arith.subi %6#2, %3 : i256 loc(#loc19) +// CHECK-NEXT: %10 = arith.addi %9, %c31_i256 : i256 loc(#loc19) +// CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %12 = arith.addi %3, %11 : i256 loc(#loc19) +// CHECK-NEXT: %13 = arith.cmpi ugt, %12, %c18446744073709551615_i256 : i256 loc(#loc19) +// CHECK-NEXT: %14 = arith.cmpi ult, %12, %3 : i256 loc(#loc19) +// CHECK-NEXT: %15 = arith.ori %13, %14 : i1 loc(#loc19) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc19) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %12, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: return %3 : i256 loc(#loc20) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: func.func @ep_nested_u16_storage_59() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c16_i256 = arith.constant 16 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc22) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc22) +// CHECK-NEXT: %3 = arith.addi %1, %c224_i256 : i256 loc(#loc22) +// CHECK-NEXT: %4:3 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256, %arg3 = %3) -> (i256, i256, i256) { +// CHECK-NEXT: %15 = arith.addi %arg1, %c64_i256 : i256 loc(#loc22) +// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc22) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc22) +// CHECK-NEXT: %18:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %arg1, %arg6 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %21 = arith.shrui %17, %arg6 : i256 loc(#loc22) +// CHECK-NEXT: %22 = arith.trunci %21 : i256 to i16 loc(#loc22) +// CHECK-NEXT: %23 = arith.extui %22 : i16 to i256 loc(#loc22) +// CHECK-NEXT: %24 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %25 = arith.addi %arg5, %c32_i256 : i256 loc(#loc22) +// CHECK-NEXT: %26 = arith.addi %arg6, %c16_i256 : i256 loc(#loc22) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc22) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc22) +// CHECK-NEXT: %19 = arith.addi %arg1, %c64_i256 : i256 loc(#loc22) +// CHECK-NEXT: %20 = arith.addi %arg2, %c1_i256 : i256 loc(#loc22) +// CHECK-NEXT: scf.yield %19, %20, %15 : i256, i256, i256 loc(#loc22) +// CHECK-NEXT: } loc(#loc22) +// CHECK-NEXT: %5 = arith.subi %4#2, %2 : i256 loc(#loc22) +// CHECK-NEXT: %6 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %7 = arith.subi %4#2, %1 : i256 loc(#loc22) +// CHECK-NEXT: %8 = arith.addi %7, %c31_i256 : i256 loc(#loc22) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc22) +// CHECK-NEXT: %10 = arith.addi %1, %9 : i256 loc(#loc22) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc22) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %1 : i256 loc(#loc22) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc22) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc22) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc22) +// CHECK-NEXT: } loc(#loc22) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: return %1 : i256 loc(#loc23) +// CHECK-NEXT: } loc(#loc21) +// CHECK-NEXT: func.func @ep_nested_u16_calldata_48(%arg0: i256 loc({{.*}}:10:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc25) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc25) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc25) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc26) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc27) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %5 = arith.addi %3, %c224_i256 : i256 loc(#loc27) +// CHECK-NEXT: %6:3 = scf.for %arg1 = %c0 to %c3 step %c1 iter_args(%arg2 = %4, %arg3 = %1, %arg4 = %5) -> (i256, i256, i256) { +// CHECK-NEXT: %17 = arith.addi %arg2, %c64_i256 : i256 loc(#loc27) +// CHECK-NEXT: %18:2 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg2, %arg7 = %arg3) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<2> loc(#loc27) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc27) +// CHECK-NEXT: %23 = arith.trunci %22 : i256 to i16 loc(#loc27) +// CHECK-NEXT: %24 = arith.extui %23 : i16 to i256 loc(#loc27) +// CHECK-NEXT: %25 = arith.cmpi ne, %22, %24 : i256 loc(#loc27) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc27) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %26 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %24, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %27 = arith.addi %arg6, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %28 = arith.addi %arg7, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: scf.yield %27, %28 : i256, i256 loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %19 = arith.addi %arg2, %c64_i256 : i256 loc(#loc27) +// CHECK-NEXT: %20 = arith.addi %arg3, %c64_i256 : i256 loc(#loc27) +// CHECK-NEXT: scf.yield %19, %20, %17 : i256, i256, i256 loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %7 = arith.subi %6#2, %4 : i256 loc(#loc27) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %9 = arith.subi %6#2, %3 : i256 loc(#loc27) +// CHECK-NEXT: %10 = arith.addi %9, %c31_i256 : i256 loc(#loc27) +// CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %12 = arith.addi %3, %11 : i256 loc(#loc27) +// CHECK-NEXT: %13 = arith.cmpi ugt, %12, %c18446744073709551615_i256 : i256 loc(#loc27) +// CHECK-NEXT: %14 = arith.cmpi ult, %12, %3 : i256 loc(#loc27) +// CHECK-NEXT: %15 = arith.ori %13, %14 : i1 loc(#loc27) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc27) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %12, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: return %3 : i256 loc(#loc28) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: func.func @ep_nested_u16_memory_31(%arg0: i256 loc({{.*}}:6:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc30) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc30) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc30) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc31) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc32) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc32) +// CHECK-NEXT: %5 = arith.addi %3, %c224_i256 : i256 loc(#loc32) +// CHECK-NEXT: %6:3 = scf.for %arg1 = %c0 to %c3 step %c1 iter_args(%arg2 = %4, %arg3 = %1, %arg4 = %5) -> (i256, i256, i256) { +// CHECK-NEXT: %17 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc32) +// CHECK-NEXT: %19 = arith.addi %arg2, %c64_i256 : i256 loc(#loc32) +// CHECK-NEXT: %20:2 = scf.for %arg5 = %c0 to %c2 step %c1 iter_args(%arg6 = %arg2, %arg7 = %18) -> (i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc32) +// CHECK-NEXT: %25 = arith.trunci %24 : i256 to i16 loc(#loc32) +// CHECK-NEXT: %26 = arith.extui %25 : i16 to i256 loc(#loc32) +// CHECK-NEXT: %27 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %28 = arith.addi %arg6, %c32_i256 : i256 loc(#loc32) +// CHECK-NEXT: %29 = arith.addi %arg7, %c32_i256 : i256 loc(#loc32) +// CHECK-NEXT: scf.yield %28, %29 : i256, i256 loc(#loc32) +// CHECK-NEXT: } loc(#loc32) +// CHECK-NEXT: %21 = arith.addi %arg2, %c64_i256 : i256 loc(#loc32) +// CHECK-NEXT: %22 = arith.addi %arg3, %c32_i256 : i256 loc(#loc32) +// CHECK-NEXT: scf.yield %21, %22, %19 : i256, i256, i256 loc(#loc32) +// CHECK-NEXT: } loc(#loc32) +// CHECK-NEXT: %7 = arith.subi %6#2, %4 : i256 loc(#loc32) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %9 = arith.subi %6#2, %3 : i256 loc(#loc32) +// CHECK-NEXT: %10 = arith.addi %9, %c31_i256 : i256 loc(#loc32) +// CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc32) +// CHECK-NEXT: %12 = arith.addi %3, %11 : i256 loc(#loc32) +// CHECK-NEXT: %13 = arith.cmpi ugt, %12, %c18446744073709551615_i256 : i256 loc(#loc32) +// CHECK-NEXT: %14 = arith.cmpi ult, %12, %3 : i256 loc(#loc32) +// CHECK-NEXT: %15 = arith.ori %13, %14 : i1 loc(#loc32) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc32) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc32) +// CHECK-NEXT: } loc(#loc32) +// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %12, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: return %3 : i256 loc(#loc33) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: #loc = loc(unknown) +// CHECK-NEXT: #loc1 = loc({{.*}}:2:0) +// CHECK-NEXT: #loc2 = loc({{.*}}:30:2) +// CHECK-NEXT: #loc4 = loc({{.*}}:31:28) +// CHECK-NEXT: #loc5 = loc({{.*}}:31:11) +// CHECK-NEXT: #loc6 = loc({{.*}}:31:4) +// CHECK-NEXT: #loc7 = loc({{.*}}:26:2) +// CHECK-NEXT: #loc8 = loc({{.*}}:4:2) +// CHECK-NEXT: #loc9 = loc({{.*}}:27:11) +// CHECK-NEXT: #loc10 = loc({{.*}}:27:4) +// CHECK-NEXT: #loc11 = loc({{.*}}:22:2) +// CHECK-NEXT: #loc13 = loc({{.*}}:23:28) +// CHECK-NEXT: #loc14 = loc({{.*}}:23:11) +// CHECK-NEXT: #loc15 = loc({{.*}}:23:4) +// CHECK-NEXT: #loc16 = loc({{.*}}:18:2) +// CHECK-NEXT: #loc18 = loc({{.*}}:19:28) +// CHECK-NEXT: #loc19 = loc({{.*}}:19:11) +// CHECK-NEXT: #loc20 = loc({{.*}}:19:4) +// CHECK-NEXT: #loc21 = loc({{.*}}:14:2) +// CHECK-NEXT: #loc22 = loc({{.*}}:15:11) +// CHECK-NEXT: #loc23 = loc({{.*}}:15:4) +// CHECK-NEXT: #loc24 = loc({{.*}}:10:2) +// CHECK-NEXT: #loc26 = loc({{.*}}:11:28) +// CHECK-NEXT: #loc27 = loc({{.*}}:11:11) +// CHECK-NEXT: #loc28 = loc({{.*}}:11:4) +// CHECK-NEXT: #loc29 = loc({{.*}}:6:2) +// CHECK-NEXT: #loc31 = loc({{.*}}:7:28) +// CHECK-NEXT: #loc32 = loc({{.*}}:7:11) +// CHECK-NEXT: #loc33 = loc({{.*}}:7:4) +// CHECK-EMPTY: diff --git a/test/lit/mlirCodegen/EVM/abi-encode-packed-storage-array.sol b/test/lit/mlirCodegen/EVM/abi-encode-packed-storage-array.sol new file mode 100644 index 000000000..8c631fc72 --- /dev/null +++ b/test/lit/mlirCodegen/EVM/abi-encode-packed-storage-array.sol @@ -0,0 +1,955 @@ +// RUN: solc --mlir-action=print-std-mlir --mlir-target=evm --mmlir --mlir-print-debuginfo %s | FileCheck %s + +contract C { + uint256[] dyn256; + uint128[] dyn128; + uint8[] dyn8; + + uint256[10] static256x10; + uint128[3] static128x3; + uint8[31] static8x31; + uint8[32] static8x32; + uint8[33] static8x33; + + function ep_u256_array_dynamic_storage() public view returns (bytes memory) { + return abi.encodePacked(dyn256); + } + + function ep_u128_array_dynamic_storage() public view returns (bytes memory) { + return abi.encodePacked(dyn128); + } + + function ep_u8_array_dynamic_storage() public view returns (bytes memory) { + return abi.encodePacked(dyn8); + } + + function ep_u256_array_static_storage() public view returns (bytes memory) { + return abi.encodePacked(static256x10); + } + + function ep_u128_array_static_storage() public view returns (bytes memory) { + return abi.encodePacked(static128x3); + } + + function ep_u8_array_static_storage_31() public view returns (bytes memory) { + return abi.encodePacked(static8x31); + } + + function ep_u8_array_static_storage_32() public view returns (bytes memory) { + return abi.encodePacked(static8x32); + } + + function ep_u8_array_static_storage_33() public view returns (bytes memory) { + return abi.encodePacked(static8x33); + } +} +// NOTE: Assertions have been autogenerated by test/updFileCheckTest.py +// CHECK: #Osaka = #sol +// CHECK-NEXT: #loop_unroll = #llvm.loop_unroll +// CHECK-NEXT: #loop_annotation = #llvm.loop_annotation +// CHECK-NEXT: module @C_118 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %0 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %2 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_118"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %4 = "llvm.intrcall"() <{id = 4042 : i32, name = "evm.codesize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @C_118() : () -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_118_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_118_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @C_118() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: return loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: module @C_118_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %0 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %2 = arith.cmpi uge, %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %2 { +// CHECK-NEXT: %4 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %6 = arith.shrui %5, %c224_i256 : i256 loc(#loc1) +// CHECK-NEXT: %7 = arith.trunci %6 : i256 to i32 loc(#loc1) +// CHECK-NEXT: scf.int_switch %7 : i32 +// CHECK-NEXT: case -357238018 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u256_array_dynamic_storage_40() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -143979229 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u128_array_dynamic_storage_51() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 1375946233 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u8_array_dynamic_storage_62() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1299755288 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u256_array_static_storage_73() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 701983862 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u128_array_static_storage_84() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 1582307317 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u8_array_static_storage_31_95() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 1893918604 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u8_array_static_storage_32_106() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1930288040 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_u8_array_static_storage_33_117() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: default { +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%3, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @ep_u8_array_static_storage_33_117() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c18_i256 = arith.constant 18 : i256 loc(#loc) +// CHECK-NEXT: %c1088_i256 = arith.constant 1088 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c17_i256 = arith.constant 17 : i256 loc(#loc3) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc4) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %3 = arith.addi %1, %c1088_i256 : i256 loc(#loc4) +// CHECK-NEXT: %4 = llvm.inttoptr %c17_i256 : i256 to !llvm.ptr<5> loc(#loc4) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc4) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c32 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %19 = arith.shrui %5, %arg2 : i256 loc(#loc4) +// CHECK-NEXT: %20 = arith.trunci %19 : i256 to i8 loc(#loc4) +// CHECK-NEXT: %21 = arith.extui %20 : i8 to i256 loc(#loc4) +// CHECK-NEXT: %22 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %23 = arith.addi %arg1, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %24 = arith.addi %arg2, %c8_i256 : i256 loc(#loc4) +// CHECK-NEXT: scf.yield %23, %24 : i256, i256 loc(#loc4) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc4) +// CHECK-NEXT: %7 = llvm.inttoptr %c18_i256 : i256 to !llvm.ptr<5> loc(#loc4) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc4) +// CHECK-NEXT: %9 = arith.trunci %8 : i256 to i8 loc(#loc4) +// CHECK-NEXT: %10 = arith.extui %9 : i8 to i256 loc(#loc4) +// CHECK-NEXT: %11 = llvm.inttoptr %6#0 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %12 = arith.subi %3, %2 : i256 loc(#loc4) +// CHECK-NEXT: %13 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %14 = arith.addi %1, %c1088_i256 : i256 loc(#loc4) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %16 = arith.cmpi ult, %14, %1 : i256 loc(#loc4) +// CHECK-NEXT: %17 = arith.ori %15, %16 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: return %1 : i256 loc(#loc5) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: func.func @ep_u8_array_static_storage_32_106() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1056_i256 = arith.constant 1056 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c16_i256 = arith.constant 16 : i256 loc(#loc7) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc8) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %3 = arith.addi %1, %c1056_i256 : i256 loc(#loc8) +// CHECK-NEXT: %4 = llvm.inttoptr %c16_i256 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c32 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %14 = arith.shrui %5, %arg2 : i256 loc(#loc8) +// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc8) +// CHECK-NEXT: %16 = arith.extui %15 : i8 to i256 loc(#loc8) +// CHECK-NEXT: %17 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %18 = arith.addi %arg1, %c32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %19 = arith.addi %arg2, %c8_i256 : i256 loc(#loc8) +// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc8) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc8) +// CHECK-NEXT: %7 = arith.subi %3, %2 : i256 loc(#loc8) +// CHECK-NEXT: %8 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %9 = arith.addi %1, %c1056_i256 : i256 loc(#loc8) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc8) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %1 : i256 loc(#loc8) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc8) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: return %1 : i256 loc(#loc9) +// CHECK-NEXT: } loc(#loc6) +// CHECK-NEXT: func.func @ep_u8_array_static_storage_31_95() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1024_i256 = arith.constant 1024 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c31 = arith.constant 31 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c15_i256 = arith.constant 15 : i256 loc(#loc11) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc12) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %3 = arith.addi %1, %c1024_i256 : i256 loc(#loc12) +// CHECK-NEXT: %4 = llvm.inttoptr %c15_i256 : i256 to !llvm.ptr<5> loc(#loc12) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc12) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c31 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %14 = arith.shrui %5, %arg2 : i256 loc(#loc12) +// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc12) +// CHECK-NEXT: %16 = arith.extui %15 : i8 to i256 loc(#loc12) +// CHECK-NEXT: %17 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %18 = arith.addi %arg1, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %19 = arith.addi %arg2, %c8_i256 : i256 loc(#loc12) +// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc12) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc12) +// CHECK-NEXT: %7 = arith.subi %3, %2 : i256 loc(#loc12) +// CHECK-NEXT: %8 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %9 = arith.addi %1, %c1024_i256 : i256 loc(#loc12) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc12) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %1 : i256 loc(#loc12) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc12) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc12) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: return %1 : i256 loc(#loc13) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: func.func @ep_u128_array_static_storage_84() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c14_i256 = arith.constant 14 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c13_i256 = arith.constant 13 : i256 loc(#loc15) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %3 = arith.addi %1, %c128_i256 : i256 loc(#loc16) +// CHECK-NEXT: %4 = llvm.inttoptr %c13_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %19 = arith.shrui %5, %arg2 : i256 loc(#loc16) +// CHECK-NEXT: %20 = arith.trunci %19 : i256 to i128 loc(#loc16) +// CHECK-NEXT: %21 = arith.extui %20 : i128 to i256 loc(#loc16) +// CHECK-NEXT: %22 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %23 = arith.addi %arg1, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %24 = arith.addi %arg2, %c128_i256 : i256 loc(#loc16) +// CHECK-NEXT: scf.yield %23, %24 : i256, i256 loc(#loc16) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc16) +// CHECK-NEXT: %7 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %9 = arith.trunci %8 : i256 to i128 loc(#loc16) +// CHECK-NEXT: %10 = arith.extui %9 : i128 to i256 loc(#loc16) +// CHECK-NEXT: %11 = llvm.inttoptr %6#0 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %12 = arith.subi %3, %2 : i256 loc(#loc16) +// CHECK-NEXT: %13 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %14 = arith.addi %1, %c128_i256 : i256 loc(#loc16) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc16) +// CHECK-NEXT: %16 = arith.cmpi ult, %14, %1 : i256 loc(#loc16) +// CHECK-NEXT: %17 = arith.ori %15, %16 : i1 loc(#loc16) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: return %1 : i256 loc(#loc17) +// CHECK-NEXT: } loc(#loc14) +// CHECK-NEXT: func.func @ep_u256_array_static_storage_73() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c352_i256 = arith.constant 352 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c10 = arith.constant 10 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 loc(#loc19) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %3 = arith.addi %1, %c352_i256 : i256 loc(#loc20) +// CHECK-NEXT: %4:2 = scf.for %arg0 = %c0 to %c10 step %c1 iter_args(%arg1 = %2, %arg2 = %c3_i256) -> (i256, i256) { +// CHECK-NEXT: %12 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc20) +// CHECK-NEXT: %14 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %15 = arith.addi %arg1, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %16 = arith.addi %arg2, %c1_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.yield %15, %16 : i256, i256 loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %5 = arith.subi %3, %2 : i256 loc(#loc20) +// CHECK-NEXT: %6 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %7 = arith.addi %1, %c352_i256 : i256 loc(#loc20) +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %1 : i256 loc(#loc20) +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 loc(#loc20) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c65_i256, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%14, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: return %1 : i256 loc(#loc21) +// CHECK-NEXT: } loc(#loc18) +// CHECK-NEXT: func.func @ep_u8_array_dynamic_storage_62() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c31 = arith.constant 31 : index loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc23) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc24) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %3 = llvm.inttoptr %c2_i256 : i256 to !llvm.ptr<5> loc(#loc24) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc24) +// CHECK-NEXT: %5 = arith.index_castui %4 : i256 to index loc(#loc24) +// CHECK-NEXT: %6 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c2_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %7 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %8 = "llvm.intrcall"(%7, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc24) +// CHECK-NEXT: %9 = arith.muli %4, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %10 = arith.addi %2, %9 : i256 loc(#loc24) +// CHECK-NEXT: %11 = arith.cmpi uge, %5, %c32 : index loc(#loc24) +// CHECK-NEXT: %12 = arith.subi %5, %c31 : index loc(#loc24) +// CHECK-NEXT: %13 = arith.select %11, %12, %c0 : index loc(#loc24) +// CHECK-NEXT: %14:3 = scf.for %arg0 = %c0 to %13 step %c32 iter_args(%arg1 = %2, %arg2 = %8, %arg3 = %c0) -> (i256, i256, index) { +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc24) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc24) +// CHECK-NEXT: %27:2 = scf.for %arg4 = %c0 to %c32 step %c1 iter_args(%arg5 = %arg1, %arg6 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %30 = arith.shrui %26, %arg6 : i256 loc(#loc24) +// CHECK-NEXT: %31 = arith.trunci %30 : i256 to i8 loc(#loc24) +// CHECK-NEXT: %32 = arith.extui %31 : i8 to i256 loc(#loc24) +// CHECK-NEXT: %33 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %34 = arith.addi %arg5, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %35 = arith.addi %arg6, %c8_i256 : i256 loc(#loc24) +// CHECK-NEXT: scf.yield %34, %35 : i256, i256 loc(#loc24) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc24) +// CHECK-NEXT: %28 = arith.addi %arg2, %c1_i256 : i256 loc(#loc24) +// CHECK-NEXT: %29 = arith.addi %arg3, %c32 : index loc(#loc24) +// CHECK-NEXT: scf.yield %27#0, %28, %29 : i256, i256, index loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %15 = arith.cmpi ult, %14#2, %5 : index loc(#loc24) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %25 = llvm.inttoptr %14#1 : i256 to !llvm.ptr<5> loc(#loc24) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc24) +// CHECK-NEXT: %27:2 = scf.for %arg0 = %14#2 to %5 step %c1 iter_args(%arg1 = %14#0, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %28 = arith.shrui %26, %arg2 : i256 loc(#loc24) +// CHECK-NEXT: %29 = arith.trunci %28 : i256 to i8 loc(#loc24) +// CHECK-NEXT: %30 = arith.extui %29 : i8 to i256 loc(#loc24) +// CHECK-NEXT: %31 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %32 = arith.addi %arg1, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %33 = arith.addi %arg2, %c8_i256 : i256 loc(#loc24) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %16 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %9, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %17 = arith.subi %10, %1 : i256 loc(#loc24) +// CHECK-NEXT: %18 = arith.addi %17, %c31_i256 : i256 loc(#loc24) +// CHECK-NEXT: %19 = arith.andi %18, %c-32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %20 = arith.addi %1, %19 : i256 loc(#loc24) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc24) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %1 : i256 loc(#loc24) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc24) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %26 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c65_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: "llvm.intrcall"(%27, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc24) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: return %1 : i256 loc(#loc25) +// CHECK-NEXT: } loc(#loc22) +// CHECK-NEXT: func.func @ep_u128_array_dynamic_storage_51() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc27) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %3 = llvm.inttoptr %c1_i256 : i256 to !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc27) +// CHECK-NEXT: %5 = arith.index_castui %4 : i256 to index loc(#loc27) +// CHECK-NEXT: %6 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %c1_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %7 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %8 = "llvm.intrcall"(%7, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc27) +// CHECK-NEXT: %9 = arith.muli %4, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %10 = arith.addi %2, %9 : i256 loc(#loc27) +// CHECK-NEXT: %11 = arith.cmpi uge, %5, %c2 : index loc(#loc27) +// CHECK-NEXT: %12 = arith.subi %5, %c1 : index loc(#loc27) +// CHECK-NEXT: %13 = arith.select %11, %12, %c0 : index loc(#loc27) +// CHECK-NEXT: %14:3 = scf.for %arg0 = %c0 to %13 step %c2 iter_args(%arg1 = %2, %arg2 = %8, %arg3 = %c0) -> (i256, i256, index) { +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc27) +// CHECK-NEXT: %27:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %arg1, %arg6 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %30 = arith.shrui %26, %arg6 : i256 loc(#loc27) +// CHECK-NEXT: %31 = arith.trunci %30 : i256 to i128 loc(#loc27) +// CHECK-NEXT: %32 = arith.extui %31 : i128 to i256 loc(#loc27) +// CHECK-NEXT: %33 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %34 = arith.addi %arg5, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %35 = arith.addi %arg6, %c128_i256 : i256 loc(#loc27) +// CHECK-NEXT: scf.yield %34, %35 : i256, i256 loc(#loc27) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc27) +// CHECK-NEXT: %28 = arith.addi %arg2, %c1_i256 : i256 loc(#loc27) +// CHECK-NEXT: %29 = arith.addi %arg3, %c2 : index loc(#loc27) +// CHECK-NEXT: scf.yield %27#0, %28, %29 : i256, i256, index loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %15 = arith.cmpi ult, %14#2, %5 : index loc(#loc27) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %25 = llvm.inttoptr %14#1 : i256 to !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc27) +// CHECK-NEXT: %27:2 = scf.for %arg0 = %14#2 to %5 step %c1 iter_args(%arg1 = %14#0, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %28 = arith.shrui %26, %arg2 : i256 loc(#loc27) +// CHECK-NEXT: %29 = arith.trunci %28 : i256 to i128 loc(#loc27) +// CHECK-NEXT: %30 = arith.extui %29 : i128 to i256 loc(#loc27) +// CHECK-NEXT: %31 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %32 = arith.addi %arg1, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %33 = arith.addi %arg2, %c128_i256 : i256 loc(#loc27) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %16 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %9, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %17 = arith.subi %10, %1 : i256 loc(#loc27) +// CHECK-NEXT: %18 = arith.addi %17, %c31_i256 : i256 loc(#loc27) +// CHECK-NEXT: %19 = arith.andi %18, %c-32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %20 = arith.addi %1, %19 : i256 loc(#loc27) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc27) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %1 : i256 loc(#loc27) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc27) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %26 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %c65_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: "llvm.intrcall"(%27, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc27) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: return %1 : i256 loc(#loc28) +// CHECK-NEXT: } loc(#loc26) +// CHECK-NEXT: func.func @ep_u256_array_dynamic_storage_40() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc30) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc30) +// CHECK-NEXT: %5 = arith.index_castui %4 : i256 to index loc(#loc30) +// CHECK-NEXT: %6 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c0_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %7 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %8 = "llvm.intrcall"(%7, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc30) +// CHECK-NEXT: %9 = arith.muli %4, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %10 = arith.addi %2, %9 : i256 loc(#loc30) +// CHECK-NEXT: %11:2 = scf.for %arg0 = %c0 to %5 step %c1 iter_args(%arg1 = %2, %arg2 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc30) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc30) +// CHECK-NEXT: %23 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %24 = arith.addi %arg1, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %25 = arith.addi %arg2, %c1_i256 : i256 loc(#loc30) +// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc30) +// CHECK-NEXT: } loc(#loc30) +// CHECK-NEXT: %12 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %13 = arith.subi %10, %1 : i256 loc(#loc30) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc30) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %16 = arith.addi %1, %15 : i256 loc(#loc30) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc30) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %1 : i256 loc(#loc30) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc30) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) +// CHECK-NEXT: } loc(#loc30) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: return %1 : i256 loc(#loc31) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: #loc = loc(unknown) +// CHECK-NEXT: #loc1 = loc({{.*}}:2:0) +// CHECK-NEXT: #loc2 = loc({{.*}}:41:2) +// CHECK-NEXT: #loc3 = loc({{.*}}:11:2) +// CHECK-NEXT: #loc4 = loc({{.*}}:42:11) +// CHECK-NEXT: #loc5 = loc({{.*}}:42:4) +// CHECK-NEXT: #loc6 = loc({{.*}}:37:2) +// CHECK-NEXT: #loc7 = loc({{.*}}:10:2) +// CHECK-NEXT: #loc8 = loc({{.*}}:38:11) +// CHECK-NEXT: #loc9 = loc({{.*}}:38:4) +// CHECK-NEXT: #loc10 = loc({{.*}}:33:2) +// CHECK-NEXT: #loc11 = loc({{.*}}:9:2) +// CHECK-NEXT: #loc12 = loc({{.*}}:34:11) +// CHECK-NEXT: #loc13 = loc({{.*}}:34:4) +// CHECK-NEXT: #loc14 = loc({{.*}}:29:2) +// CHECK-NEXT: #loc15 = loc({{.*}}:8:2) +// CHECK-NEXT: #loc16 = loc({{.*}}:30:11) +// CHECK-NEXT: #loc17 = loc({{.*}}:30:4) +// CHECK-NEXT: #loc18 = loc({{.*}}:25:2) +// CHECK-NEXT: #loc19 = loc({{.*}}:7:2) +// CHECK-NEXT: #loc20 = loc({{.*}}:26:11) +// CHECK-NEXT: #loc21 = loc({{.*}}:26:4) +// CHECK-NEXT: #loc22 = loc({{.*}}:21:2) +// CHECK-NEXT: #loc23 = loc({{.*}}:5:2) +// CHECK-NEXT: #loc24 = loc({{.*}}:22:11) +// CHECK-NEXT: #loc25 = loc({{.*}}:22:4) +// CHECK-NEXT: #loc26 = loc({{.*}}:17:2) +// CHECK-NEXT: #loc27 = loc({{.*}}:18:11) +// CHECK-NEXT: #loc28 = loc({{.*}}:18:4) +// CHECK-NEXT: #loc29 = loc({{.*}}:13:2) +// CHECK-NEXT: #loc30 = loc({{.*}}:14:11) +// CHECK-NEXT: #loc31 = loc({{.*}}:14:4) +// CHECK-EMPTY: diff --git a/test/lit/mlirCodegen/EVM/abi-encode-storage-array.sol b/test/lit/mlirCodegen/EVM/abi-encode-storage-array.sol new file mode 100644 index 000000000..05abdd41f --- /dev/null +++ b/test/lit/mlirCodegen/EVM/abi-encode-storage-array.sol @@ -0,0 +1,1291 @@ +// RUN: solc --mlir-action=print-std-mlir --mlir-target=evm --mmlir --mlir-print-debuginfo %s | FileCheck %s + +contract C { + struct U256Pair { + uint256 left; + uint256 right; + } + + uint256[] dyn256; + + uint8[4] static8x4; + uint8[31] static8x31; + uint8[32] static8x32; + uint8[33] static8x33; + uint256[3] static256x3; + + uint256[][] dynRefDyn256; + uint256[2][] dynRefStatic2x; + uint256[][2] staticRefDyn256x2; + U256Pair[] dynStructPair; + U256Pair[2] staticStructPair2; + + function ei_u256_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dyn256); + } + + function ei_u8_array_static_storage_4() public view returns (bytes memory) { + return abi.encode(static8x4); + } + + function ei_u8_array_static_storage_31() public view returns (bytes memory) { + return abi.encode(static8x31); + } + + function ei_u8_array_static_storage_32() public view returns (bytes memory) { + return abi.encode(static8x32); + } + + function ei_u8_array_static_storage_33() public view returns (bytes memory) { + return abi.encode(static8x33); + } + + function ei_u256_array_static_storage_3() public view returns (bytes memory) { + return abi.encode(static256x3); + } + + function ei_u256_array_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dynRefDyn256); + } + + function ei_u256x2_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dynRefStatic2x); + } + + function ei_u256_array_static_storage_2() public view returns (bytes memory) { + return abi.encode(staticRefDyn256x2); + } + + function ei_u256_pair_array_dynamic_storage() public view returns (bytes memory) { + return abi.encode(dynStructPair); + } + + function ei_u256_pair_array_static_storage_2() public view returns (bytes memory) { + return abi.encode(staticStructPair2); + } +} +// NOTE: Assertions have been autogenerated by test/updFileCheckTest.py +// CHECK: #Osaka = #sol +// CHECK-NEXT: #loop_unroll = #llvm.loop_unroll +// CHECK-NEXT: #loop_annotation = #llvm.loop_annotation +// CHECK-NEXT: module @C_173 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %0 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %2 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_173"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %4 = "llvm.intrcall"() <{id = 4042 : i32, name = "evm.codesize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @C_173() : () -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_173_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_173_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @C_173() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: return loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: module @C_173_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c128_i256, %0 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %2 = arith.cmpi uge, %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %2 { +// CHECK-NEXT: %4 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %6 = arith.shrui %5, %c224_i256 : i256 loc(#loc1) +// CHECK-NEXT: %7 = arith.trunci %6 : i256 to i32 loc(#loc1) +// CHECK-NEXT: scf.int_switch %7 : i32 +// CHECK-NEXT: case 716411912 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u256_array_dynamic_storage_62() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -190288020 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u8_array_static_storage_4_73() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1993667675 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u8_array_static_storage_31_84() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 1830252312 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u8_array_static_storage_32_95() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 1849559523 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u8_array_static_storage_33_106() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 760801724 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u256_array_static_storage_3_117() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1840646124 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u256_array_array_dynamic_storage_128() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 223097156 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u256x2_array_dynamic_storage_139() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1962674198 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u256_array_static_storage_2_150() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1074160449 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u256_pair_array_dynamic_storage_161() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 2070358238 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @ei_u256_pair_array_static_storage_2_172() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: default { +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%3, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: llvm.unreachable loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: func.func @ei_u256_pair_array_static_storage_2_172() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c14_i256 = arith.constant 14 : i256 loc(#loc3) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc4) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %3 = arith.addi %1, %c160_i256 : i256 loc(#loc4) +// CHECK-NEXT: %4:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %2, %arg2 = %c14_i256) -> (i256, i256) { +// CHECK-NEXT: %12 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc4) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc4) +// CHECK-NEXT: %14 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %15 = arith.addi %arg1, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %16 = arith.addi %arg2, %c1_i256 : i256 loc(#loc4) +// CHECK-NEXT: %17 = llvm.inttoptr %16 : i256 to !llvm.ptr<5> loc(#loc4) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc4) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %20 = arith.addi %arg1, %c64_i256 : i256 loc(#loc4) +// CHECK-NEXT: %21 = arith.addi %arg2, %c2_i256 : i256 loc(#loc4) +// CHECK-NEXT: scf.yield %20, %21 : i256, i256 loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %5 = arith.subi %3, %2 : i256 loc(#loc4) +// CHECK-NEXT: %6 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %7 = arith.addi %1, %c160_i256 : i256 loc(#loc4) +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %1 : i256 loc(#loc4) +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%14, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: return %1 : i256 loc(#loc5) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: func.func @ei_u256_pair_array_dynamic_storage_161() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c13_i256 = arith.constant 13 : i256 loc(#loc7) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc8) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc8) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc8) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %6 = llvm.inttoptr %c13_i256 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %9 = arith.index_castui %7 : i256 to index loc(#loc8) +// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc8) +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c13_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %13 = "llvm.intrcall"(%12, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc8) +// CHECK-NEXT: %14 = arith.muli %7, %c64_i256 : i256 loc(#loc8) +// CHECK-NEXT: %15 = arith.addi %10, %14 : i256 loc(#loc8) +// CHECK-NEXT: %16:3 = scf.for %arg0 = %c0 to %9 step %c1 iter_args(%arg1 = %10, %arg2 = %13, %arg3 = %15) -> (i256, i256, i256) { +// CHECK-NEXT: %27 = arith.addi %arg1, %c64_i256 : i256 loc(#loc8) +// CHECK-NEXT: %28 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) +// CHECK-NEXT: %30 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %31 = arith.addi %arg1, %c32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %32 = arith.addi %arg2, %c1_i256 : i256 loc(#loc8) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) +// CHECK-NEXT: %35 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %36 = arith.addi %arg1, %c64_i256 : i256 loc(#loc8) +// CHECK-NEXT: %37 = arith.addi %arg2, %c2_i256 : i256 loc(#loc8) +// CHECK-NEXT: scf.yield %36, %37, %27 : i256, i256, i256 loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %17 = arith.subi %16#2, %2 : i256 loc(#loc8) +// CHECK-NEXT: %18 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %19 = arith.subi %16#2, %1 : i256 loc(#loc8) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc8) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %22 = arith.addi %1, %21 : i256 loc(#loc8) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc8) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %1 : i256 loc(#loc8) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc8) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: return %1 : i256 loc(#loc9) +// CHECK-NEXT: } loc(#loc6) +// CHECK-NEXT: func.func @ei_u256_array_static_storage_2_150() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c11_i256 = arith.constant 11 : i256 loc(#loc11) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc12) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc12) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc12) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %6 = arith.addi %1, %c128_i256 : i256 loc(#loc12) +// CHECK-NEXT: %7:3 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %3, %arg2 = %c11_i256, %arg3 = %6) -> (i256, i256, i256) { +// CHECK-NEXT: %18 = arith.subi %arg3, %3 : i256 loc(#loc12) +// CHECK-NEXT: %19 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %20 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc12) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc12) +// CHECK-NEXT: %22 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %23 = arith.index_castui %21 : i256 to index loc(#loc12) +// CHECK-NEXT: %24 = arith.addi %arg3, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %arg2, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %27 = "llvm.intrcall"(%26, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc12) +// CHECK-NEXT: %28 = arith.muli %21, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %29 = arith.addi %24, %28 : i256 loc(#loc12) +// CHECK-NEXT: %30:2 = scf.for %arg4 = %c0 to %23 step %c1 iter_args(%arg5 = %24, %arg6 = %27) -> (i256, i256) { +// CHECK-NEXT: %33 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<5> loc(#loc12) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc12) +// CHECK-NEXT: %35 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %36 = arith.addi %arg5, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %37 = arith.addi %arg6, %c1_i256 : i256 loc(#loc12) +// CHECK-NEXT: scf.yield %36, %37 : i256, i256 loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %31 = arith.addi %arg1, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %32 = arith.addi %arg2, %c1_i256 : i256 loc(#loc12) +// CHECK-NEXT: scf.yield %31, %32, %29 : i256, i256, i256 loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %8 = arith.subi %7#2, %2 : i256 loc(#loc12) +// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %10 = arith.subi %7#2, %1 : i256 loc(#loc12) +// CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc12) +// CHECK-NEXT: %12 = arith.andi %11, %c-32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %13 = arith.addi %1, %12 : i256 loc(#loc12) +// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc12) +// CHECK-NEXT: %15 = arith.cmpi ult, %13, %1 : i256 loc(#loc12) +// CHECK-NEXT: %16 = arith.ori %14, %15 : i1 loc(#loc12) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %19 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c65_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: "llvm.intrcall"(%20, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc12) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %13, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: return %1 : i256 loc(#loc13) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: func.func @ei_u256x2_array_dynamic_storage_139() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c10_i256 = arith.constant 10 : i256 loc(#loc15) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc16) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc16) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %6 = llvm.inttoptr %c10_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %9 = arith.index_castui %7 : i256 to index loc(#loc16) +// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc16) +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c10_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %13 = "llvm.intrcall"(%12, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc16) +// CHECK-NEXT: %14 = arith.muli %7, %c64_i256 : i256 loc(#loc16) +// CHECK-NEXT: %15 = arith.addi %10, %14 : i256 loc(#loc16) +// CHECK-NEXT: %16:3 = scf.for %arg0 = %c0 to %9 step %c1 iter_args(%arg1 = %10, %arg2 = %13, %arg3 = %15) -> (i256, i256, i256) { +// CHECK-NEXT: %27 = arith.addi %arg1, %c64_i256 : i256 loc(#loc16) +// CHECK-NEXT: %28:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %arg1, %arg6 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %31 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %32 = llvm.load %31 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %33 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %34 = arith.addi %arg5, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %35 = arith.addi %arg6, %c1_i256 : i256 loc(#loc16) +// CHECK-NEXT: scf.yield %34, %35 : i256, i256 loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %29 = arith.addi %arg1, %c64_i256 : i256 loc(#loc16) +// CHECK-NEXT: %30 = arith.addi %arg2, %c2_i256 : i256 loc(#loc16) +// CHECK-NEXT: scf.yield %29, %30, %27 : i256, i256, i256 loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %17 = arith.subi %16#2, %2 : i256 loc(#loc16) +// CHECK-NEXT: %18 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %19 = arith.subi %16#2, %1 : i256 loc(#loc16) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc16) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %22 = arith.addi %1, %21 : i256 loc(#loc16) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc16) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %1 : i256 loc(#loc16) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc16) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: return %1 : i256 loc(#loc17) +// CHECK-NEXT: } loc(#loc14) +// CHECK-NEXT: func.func @ei_u256_array_array_dynamic_storage_128() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c9_i256 = arith.constant 9 : i256 loc(#loc19) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc20) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc20) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %6 = llvm.inttoptr %c9_i256 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc20) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %9 = arith.index_castui %7 : i256 to index loc(#loc20) +// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc20) +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c9_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %13 = "llvm.intrcall"(%12, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc20) +// CHECK-NEXT: %14 = arith.muli %7, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %15 = arith.addi %10, %14 : i256 loc(#loc20) +// CHECK-NEXT: %16:3 = scf.for %arg0 = %c0 to %9 step %c1 iter_args(%arg1 = %10, %arg2 = %13, %arg3 = %15) -> (i256, i256, i256) { +// CHECK-NEXT: %27 = arith.subi %arg3, %10 : i256 loc(#loc20) +// CHECK-NEXT: %28 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %29 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc20) +// CHECK-NEXT: %31 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %32 = arith.index_castui %30 : i256 to index loc(#loc20) +// CHECK-NEXT: %33 = arith.addi %arg3, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %arg2, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %36 = "llvm.intrcall"(%35, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc20) +// CHECK-NEXT: %37 = arith.muli %30, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %38 = arith.addi %33, %37 : i256 loc(#loc20) +// CHECK-NEXT: %39:2 = scf.for %arg4 = %c0 to %32 step %c1 iter_args(%arg5 = %33, %arg6 = %36) -> (i256, i256) { +// CHECK-NEXT: %42 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc20) +// CHECK-NEXT: %44 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %45 = arith.addi %arg5, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %46 = arith.addi %arg6, %c1_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.yield %45, %46 : i256, i256 loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %40 = arith.addi %arg1, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %41 = arith.addi %arg2, %c1_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.yield %40, %41, %38 : i256, i256, i256 loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %17 = arith.subi %16#2, %2 : i256 loc(#loc20) +// CHECK-NEXT: %18 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %19 = arith.subi %16#2, %1 : i256 loc(#loc20) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %22 = arith.addi %1, %21 : i256 loc(#loc20) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %1 : i256 loc(#loc20) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc20) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: return %1 : i256 loc(#loc21) +// CHECK-NEXT: } loc(#loc18) +// CHECK-NEXT: func.func @ei_u256_array_static_storage_3_117() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c6_i256 = arith.constant 6 : i256 loc(#loc23) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc24) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %3 = arith.addi %1, %c128_i256 : i256 loc(#loc24) +// CHECK-NEXT: %4:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %2, %arg2 = %c6_i256) -> (i256, i256) { +// CHECK-NEXT: %12 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc24) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc24) +// CHECK-NEXT: %14 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %15 = arith.addi %arg1, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %16 = arith.addi %arg2, %c1_i256 : i256 loc(#loc24) +// CHECK-NEXT: scf.yield %15, %16 : i256, i256 loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %5 = arith.subi %3, %2 : i256 loc(#loc24) +// CHECK-NEXT: %6 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %7 = arith.addi %1, %c128_i256 : i256 loc(#loc24) +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 loc(#loc24) +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %1 : i256 loc(#loc24) +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 loc(#loc24) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c65_i256, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: "llvm.intrcall"(%14, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc24) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: return %1 : i256 loc(#loc25) +// CHECK-NEXT: } loc(#loc22) +// CHECK-NEXT: func.func @ei_u8_array_static_storage_33_106() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c5_i256 = arith.constant 5 : i256 loc(#loc) +// CHECK-NEXT: %c1088_i256 = arith.constant 1088 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc27) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %3 = arith.addi %1, %c1088_i256 : i256 loc(#loc27) +// CHECK-NEXT: %4 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc27) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c32 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %19 = arith.shrui %5, %arg2 : i256 loc(#loc27) +// CHECK-NEXT: %20 = arith.trunci %19 : i256 to i8 loc(#loc27) +// CHECK-NEXT: %21 = arith.extui %20 : i8 to i256 loc(#loc27) +// CHECK-NEXT: %22 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %23 = arith.addi %arg1, %c32_i256 : i256 loc(#loc27) +// CHECK-NEXT: %24 = arith.addi %arg2, %c8_i256 : i256 loc(#loc27) +// CHECK-NEXT: scf.yield %23, %24 : i256, i256 loc(#loc27) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc27) +// CHECK-NEXT: %7 = llvm.inttoptr %c5_i256 : i256 to !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc27) +// CHECK-NEXT: %9 = arith.trunci %8 : i256 to i8 loc(#loc27) +// CHECK-NEXT: %10 = arith.extui %9 : i8 to i256 loc(#loc27) +// CHECK-NEXT: %11 = llvm.inttoptr %6#0 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %12 = arith.subi %3, %2 : i256 loc(#loc27) +// CHECK-NEXT: %13 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %14 = arith.addi %1, %c1088_i256 : i256 loc(#loc27) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc27) +// CHECK-NEXT: %16 = arith.cmpi ult, %14, %1 : i256 loc(#loc27) +// CHECK-NEXT: %17 = arith.ori %15, %16 : i1 loc(#loc27) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc27) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc27) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc27) +// CHECK-NEXT: return %1 : i256 loc(#loc28) +// CHECK-NEXT: } loc(#loc26) +// CHECK-NEXT: func.func @ei_u8_array_static_storage_32_95() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1056_i256 = arith.constant 1056 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 loc(#loc30) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %3 = arith.addi %1, %c1056_i256 : i256 loc(#loc31) +// CHECK-NEXT: %4 = llvm.inttoptr %c3_i256 : i256 to !llvm.ptr<5> loc(#loc31) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc31) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c32 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %14 = arith.shrui %5, %arg2 : i256 loc(#loc31) +// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc31) +// CHECK-NEXT: %16 = arith.extui %15 : i8 to i256 loc(#loc31) +// CHECK-NEXT: %17 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %18 = arith.addi %arg1, %c32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %19 = arith.addi %arg2, %c8_i256 : i256 loc(#loc31) +// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc31) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc31) +// CHECK-NEXT: %7 = arith.subi %3, %2 : i256 loc(#loc31) +// CHECK-NEXT: %8 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %9 = arith.addi %1, %c1056_i256 : i256 loc(#loc31) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc31) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %1 : i256 loc(#loc31) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc31) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc31) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: return %1 : i256 loc(#loc32) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: func.func @ei_u8_array_static_storage_31_84() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1024_i256 = arith.constant 1024 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c31 = arith.constant 31 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc34) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %3 = arith.addi %1, %c1024_i256 : i256 loc(#loc35) +// CHECK-NEXT: %4 = llvm.inttoptr %c2_i256 : i256 to !llvm.ptr<5> loc(#loc35) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc35) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c31 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %14 = arith.shrui %5, %arg2 : i256 loc(#loc35) +// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc35) +// CHECK-NEXT: %16 = arith.extui %15 : i8 to i256 loc(#loc35) +// CHECK-NEXT: %17 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %18 = arith.addi %arg1, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %19 = arith.addi %arg2, %c8_i256 : i256 loc(#loc35) +// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc35) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc35) +// CHECK-NEXT: %7 = arith.subi %3, %2 : i256 loc(#loc35) +// CHECK-NEXT: %8 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %9 = arith.addi %1, %c1024_i256 : i256 loc(#loc35) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc35) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %1 : i256 loc(#loc35) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc35) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) +// CHECK-NEXT: } loc(#loc35) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: return %1 : i256 loc(#loc36) +// CHECK-NEXT: } loc(#loc33) +// CHECK-NEXT: func.func @ei_u8_array_static_storage_4_73() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c4 = arith.constant 4 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc38) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc38) +// CHECK-NEXT: %3 = arith.addi %1, %c160_i256 : i256 loc(#loc38) +// CHECK-NEXT: %4 = llvm.inttoptr %c1_i256 : i256 to !llvm.ptr<5> loc(#loc38) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc38) +// CHECK-NEXT: %6:2 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %2, %arg2 = %c0_i256) -> (i256, i256) { +// CHECK-NEXT: %14 = arith.shrui %5, %arg2 : i256 loc(#loc38) +// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc38) +// CHECK-NEXT: %16 = arith.extui %15 : i8 to i256 loc(#loc38) +// CHECK-NEXT: %17 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %18 = arith.addi %arg1, %c32_i256 : i256 loc(#loc38) +// CHECK-NEXT: %19 = arith.addi %arg2, %c8_i256 : i256 loc(#loc38) +// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc38) +// CHECK-NEXT: } {loop_annotation = #loop_annotation} loc(#loc38) +// CHECK-NEXT: %7 = arith.subi %3, %2 : i256 loc(#loc38) +// CHECK-NEXT: %8 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %9 = arith.addi %1, %c160_i256 : i256 loc(#loc38) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc38) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %1 : i256 loc(#loc38) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc38) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc38) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc38) +// CHECK-NEXT: } loc(#loc38) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: return %1 : i256 loc(#loc39) +// CHECK-NEXT: } loc(#loc37) +// CHECK-NEXT: func.func @ei_u256_array_dynamic_storage_62() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc41) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc41) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc41) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc41) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %6 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc41) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc41) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %9 = arith.index_castui %7 : i256 to index loc(#loc41) +// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc41) +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %c0_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %13 = "llvm.intrcall"(%12, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc41) +// CHECK-NEXT: %14 = arith.muli %7, %c32_i256 : i256 loc(#loc41) +// CHECK-NEXT: %15 = arith.addi %10, %14 : i256 loc(#loc41) +// CHECK-NEXT: %16:2 = scf.for %arg0 = %c0 to %9 step %c1 iter_args(%arg1 = %10, %arg2 = %13) -> (i256, i256) { +// CHECK-NEXT: %27 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc41) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc41) +// CHECK-NEXT: %29 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %30 = arith.addi %arg1, %c32_i256 : i256 loc(#loc41) +// CHECK-NEXT: %31 = arith.addi %arg2, %c1_i256 : i256 loc(#loc41) +// CHECK-NEXT: scf.yield %30, %31 : i256, i256 loc(#loc41) +// CHECK-NEXT: } loc(#loc41) +// CHECK-NEXT: %17 = arith.subi %15, %2 : i256 loc(#loc41) +// CHECK-NEXT: %18 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %19 = arith.subi %15, %1 : i256 loc(#loc41) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc41) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc41) +// CHECK-NEXT: %22 = arith.addi %1, %21 : i256 loc(#loc41) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc41) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %1 : i256 loc(#loc41) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc41) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc41) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc41) +// CHECK-NEXT: } loc(#loc41) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc41) +// CHECK-NEXT: return %1 : i256 loc(#loc42) +// CHECK-NEXT: } loc(#loc40) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: #loc = loc(unknown) +// CHECK-NEXT: #loc1 = loc({{.*}}:2:0) +// CHECK-NEXT: #loc2 = loc({{.*}}:62:2) +// CHECK-NEXT: #loc3 = loc({{.*}}:20:2) +// CHECK-NEXT: #loc4 = loc({{.*}}:63:11) +// CHECK-NEXT: #loc5 = loc({{.*}}:63:4) +// CHECK-NEXT: #loc6 = loc({{.*}}:58:2) +// CHECK-NEXT: #loc7 = loc({{.*}}:19:2) +// CHECK-NEXT: #loc8 = loc({{.*}}:59:11) +// CHECK-NEXT: #loc9 = loc({{.*}}:59:4) +// CHECK-NEXT: #loc10 = loc({{.*}}:54:2) +// CHECK-NEXT: #loc11 = loc({{.*}}:18:2) +// CHECK-NEXT: #loc12 = loc({{.*}}:55:11) +// CHECK-NEXT: #loc13 = loc({{.*}}:55:4) +// CHECK-NEXT: #loc14 = loc({{.*}}:50:2) +// CHECK-NEXT: #loc15 = loc({{.*}}:17:2) +// CHECK-NEXT: #loc16 = loc({{.*}}:51:11) +// CHECK-NEXT: #loc17 = loc({{.*}}:51:4) +// CHECK-NEXT: #loc18 = loc({{.*}}:46:2) +// CHECK-NEXT: #loc19 = loc({{.*}}:16:2) +// CHECK-NEXT: #loc20 = loc({{.*}}:47:11) +// CHECK-NEXT: #loc21 = loc({{.*}}:47:4) +// CHECK-NEXT: #loc22 = loc({{.*}}:42:2) +// CHECK-NEXT: #loc23 = loc({{.*}}:14:2) +// CHECK-NEXT: #loc24 = loc({{.*}}:43:11) +// CHECK-NEXT: #loc25 = loc({{.*}}:43:4) +// CHECK-NEXT: #loc26 = loc({{.*}}:38:2) +// CHECK-NEXT: #loc27 = loc({{.*}}:39:11) +// CHECK-NEXT: #loc28 = loc({{.*}}:39:4) +// CHECK-NEXT: #loc29 = loc({{.*}}:34:2) +// CHECK-NEXT: #loc30 = loc({{.*}}:12:2) +// CHECK-NEXT: #loc31 = loc({{.*}}:35:11) +// CHECK-NEXT: #loc32 = loc({{.*}}:35:4) +// CHECK-NEXT: #loc33 = loc({{.*}}:30:2) +// CHECK-NEXT: #loc34 = loc({{.*}}:11:2) +// CHECK-NEXT: #loc35 = loc({{.*}}:31:11) +// CHECK-NEXT: #loc36 = loc({{.*}}:31:4) +// CHECK-NEXT: #loc37 = loc({{.*}}:26:2) +// CHECK-NEXT: #loc38 = loc({{.*}}:27:11) +// CHECK-NEXT: #loc39 = loc({{.*}}:27:4) +// CHECK-NEXT: #loc40 = loc({{.*}}:22:2) +// CHECK-NEXT: #loc41 = loc({{.*}}:23:11) +// CHECK-NEXT: #loc42 = loc({{.*}}:23:4) +// CHECK-EMPTY: diff --git a/test/lit/mlirCodegen/EVM/abi-encode-struct.sol b/test/lit/mlirCodegen/EVM/abi-encode-struct.sol index 1af5fc096..5e51a7027 100644 --- a/test/lit/mlirCodegen/EVM/abi-encode-struct.sol +++ b/test/lit/mlirCodegen/EVM/abi-encode-struct.sol @@ -34,8 +34,13 @@ contract C { uint256 d; } - // FIXME: Enable storage encoding tests with Big/Nested once storage-array - // encoding is fixed. + struct S { + uint256 a; + uint256 b; + } + + Big storageBig; + Nested storageBigNested; StorageFlat storageFlat; StorageNested storageNested; StoragePacked storagePacked; @@ -56,6 +61,18 @@ contract C { return abi.encode(s); } + function enc_struct(S[2] calldata x) public pure returns (bytes memory) { + return abi.encode(x); + } + + function storage_big() public view returns (bytes memory) { + return abi.encode(storageBig); + } + + function storage_big_nested() public view returns (bytes memory) { + return abi.encode(storageBigNested); + } + function storage_flat() public view returns (bytes memory) { return abi.encode(storageFlat); } @@ -70,15 +87,23 @@ contract C { } // NOTE: Assertions have been autogenerated by test/updFileCheckTest.py // CHECK: #Osaka = #sol -// CHECK-NEXT: #loc14 = loc({{.*}}:54:21) -// CHECK-NEXT: #loc19 = loc({{.*}}:50:18) -// CHECK-NEXT: #loc24 = loc({{.*}}:46:22) -// CHECK-NEXT: #loc29 = loc({{.*}}:42:19) -// CHECK-NEXT: module @C_145 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: #loc22 = loc({{.*}}:63:22) +// CHECK-NEXT: #loc27 = loc({{.*}}:59:21) +// CHECK-NEXT: #loc32 = loc({{.*}}:55:18) +// CHECK-NEXT: #loc37 = loc({{.*}}:51:22) +// CHECK-NEXT: #loc42 = loc({{.*}}:47:19) +// CHECK-NEXT: module @C_194 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { // CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -87,38 +112,52 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_145"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_194"], name = "evm.datasize"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %4 = "llvm.intrcall"() <{id = 4042 : i32, name = "evm.codesize"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: call @C_145() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_145_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_145_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @C_194() : () -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_194_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_194_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) -// CHECK-NEXT: func.func @C_145() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @C_194() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: return loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: module @C_145_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: module @C_194_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { // CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) @@ -126,6 +165,9 @@ contract C { // CHECK-NEXT: %c127_i256 = arith.constant 127 : i256 loc(#loc) // CHECK-NEXT: %c164_i256 = arith.constant 164 : i256 loc(#loc) // CHECK-NEXT: %c131_i256 = arith.constant 131 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c196_i256 = arith.constant 196 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) @@ -136,25 +178,23 @@ contract C { // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) -// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256 = arith.constant 52195229743194479185619533901126580011012186126243431406710767645195241521152 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256 = arith.constant 29517451764962235613010368778373659638394623262010481743997880166685973898854 : i256 loc(#loc) -// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256 = arith.constant 50408947360703532628410820127875489391510599906502180640049823775688402927616 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256 = arith.constant 29517451764962235613010368778373660511553963533401470520153988868949248340840 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256 = arith.constant 45888551966424197807937402689295079693071411769653575580334356259971920822272 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256 = arith.constant 29517451764962235613010368778373659638394623262010481748738546747006033225331 : i256 loc(#loc) // CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) @@ -180,379 +220,432 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %113 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%113, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%129, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %113 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%113, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%129, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c196_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi ugt, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %20 = arith.addi %19, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %24 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %25 = arith.addi %13, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %19, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %25 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %13, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.addi %19, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %34 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %19 : i256 loc(#loc1) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%131, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %15, %33 : i256 loc(#loc1) -// CHECK-NEXT: %36 = arith.addi %35, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %37 = arith.cmpi sge, %36, %1 : i256 loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %13, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %19, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %13, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %19, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %33 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.cmpi ugt, %36, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %37 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %35 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %40, %39 : i256 loc(#loc1) -// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %42 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %38 = arith.addi %15, %36 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %38, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %40 = arith.cmpi sge, %39, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %40 { +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %39, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = arith.andi %43, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.cmpi ugt, %39, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %38 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = arith.addi %38, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %43, %42 : i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.cmpi ugt, %44, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %45 { -// CHECK-NEXT: %113 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %114 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%115, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %44, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %48, %46 : i256 loc(#loc1) -// CHECK-NEXT: %50 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %49, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %39, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = arith.addi %48, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %40 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%53, %54, %39) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %52, %39 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %48, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %13, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %19, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %13, %c131_i256 : i256 loc(#loc1) -// CHECK-NEXT: %61 = arith.cmpi sge, %60, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %61 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %42, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.andi %46, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.cmpi ugt, %42, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%131, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.load %62 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %64 = arith.addi %63, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %64, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %66 = arith.addi %13, %c164_i256 : i256 loc(#loc1) -// CHECK-NEXT: %67 = arith.cmpi ugt, %66, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %67 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %52 = arith.andi %51, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %50, %52 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.cmpi ugt, %53, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.cmpi ult, %53, %50 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.ori %54, %55 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %56 { +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%131, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %68:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %63, %arg2 = %58) -> (i256, i256) { -// CHECK-NEXT: %113 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %114, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %116, %117 : i256, i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %53, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %42, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %50, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.inttoptr %43 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%60, %61, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %59, %42 : i256 loc(#loc1) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %50, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %13, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.addi %19, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %13, %c131_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = arith.cmpi sge, %67, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %68 { +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %63, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %70 = arith.addi %13, %c164_i256 : i256 loc(#loc1) -// CHECK-NEXT: %71 = arith.addi %19, %c128_i256 : i256 loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %70 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = arith.cmpi ugt, %73, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %70 = llvm.load %69 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %71 = arith.addi %70, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %72 = arith.cmpi ugt, %71, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %73 = arith.cmpi ult, %71, %70 : i256 loc(#loc1) +// CHECK-NEXT: %74 = arith.ori %72, %73 : i1 loc(#loc1) // CHECK-NEXT: scf.if %74 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%131, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %15, %73 : i256 loc(#loc1) -// CHECK-NEXT: %76 = arith.addi %75, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %77 = arith.cmpi sge, %76, %1 : i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %71, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %13, %c164_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = arith.cmpi ugt, %76, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %77 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %75 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %79 = llvm.load %78 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %80 = arith.addi %75, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %81 = arith.muli %79, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = arith.addi %80, %81 : i256 loc(#loc1) -// CHECK-NEXT: %83 = arith.cmpi ugt, %82, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %83 { -// CHECK-NEXT: %113 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %114, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = llvm.inttoptr %116 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %117 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %118 = arith.addi %114, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %119 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %119 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %114, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %114, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%124, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %78:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %70, %arg2 = %65) -> (i256, i256) { +// CHECK-NEXT: %129 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %130, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %132, %133 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %70, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %13, %c164_i256 : i256 loc(#loc1) +// CHECK-NEXT: %81 = arith.addi %19, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %82 = llvm.inttoptr %80 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %83 = llvm.load %82 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %84 = arith.cmpi ugt, %83, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %84 { +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %84 = arith.muli %79, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %85 = arith.cmpi ugt, %79, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %85 { -// CHECK-NEXT: %113 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %114 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %114 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%115, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %85 = arith.addi %15, %83 : i256 loc(#loc1) +// CHECK-NEXT: %86 = arith.addi %85, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %87 = arith.cmpi sge, %86, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %87 { +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %86 = arith.addi %84, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %87 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %89 = arith.addi %88, %86 : i256 loc(#loc1) -// CHECK-NEXT: %90 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %89, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %91 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %79, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %92 = arith.addi %88, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %93 = arith.index_castui %79 : i256 to index loc(#loc1) -// CHECK-NEXT: %94:2 = scf.for %arg0 = %c0 to %93 step %c1 iter_args(%arg1 = %92, %arg2 = %80) -> (i256, i256) { -// CHECK-NEXT: %113 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %115 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %114, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %116 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %117 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %116, %117 : i256, i256 loc(#loc1) +// CHECK-NEXT: %88 = llvm.inttoptr %85 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %89 = llvm.load %88 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %85, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = arith.muli %89, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %90, %91 : i256 loc(#loc1) +// CHECK-NEXT: %93 = arith.cmpi ugt, %92, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %93 { +// CHECK-NEXT: %129 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %130, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = arith.addi %130, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = arith.addi %130, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %137 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %137 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %138 = arith.addi %130, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %139 = llvm.inttoptr %138 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %139 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%140, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %95 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %88, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %96 = func.call @mem_big_69(%19) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %97 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %98 = llvm.load %97 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %99 = arith.addi %98, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %100 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %100 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %101 = arith.addi %98, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %102 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %103 = llvm.load %102 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %104 = arith.addi %96, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %105 = llvm.inttoptr %101 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %106 = llvm.inttoptr %104 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%105, %106, %103) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %107 = llvm.inttoptr %99 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %103, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %108 = arith.addi %103, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %109 = arith.andi %108, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %110 = arith.addi %101, %109 : i256 loc(#loc1) -// CHECK-NEXT: %111 = arith.subi %110, %98 : i256 loc(#loc1) -// CHECK-NEXT: %112 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%112, %111) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %94 = arith.muli %89, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = arith.cmpi ugt, %89, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %95 { +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%131, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %97 = llvm.load %96 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %98 = arith.addi %94, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %99 = arith.andi %98, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %100 = arith.addi %97, %99 : i256 loc(#loc1) +// CHECK-NEXT: %101 = arith.cmpi ugt, %100, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %102 = arith.cmpi ult, %100, %97 : i256 loc(#loc1) +// CHECK-NEXT: %103 = arith.ori %101, %102 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %103 { +// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %130 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %130 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%131, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %104 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %100, %104 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %105 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %89, %105 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %106 = arith.addi %97, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %107 = arith.index_castui %89 : i256 to index loc(#loc1) +// CHECK-NEXT: %108:2 = scf.for %arg0 = %c0 to %107 step %c1 iter_args(%arg1 = %106, %arg2 = %90) -> (i256, i256) { +// CHECK-NEXT: %129 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %130 = llvm.load %129 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %130, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %132 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %133 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %132, %133 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %109 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %97, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %110 = func.call @mem_big_80(%19) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %111 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %112 = llvm.load %111 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %113 = arith.addi %112, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %114 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %114 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %115 = arith.addi %112, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %116 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %117 = llvm.load %116 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %118 = arith.addi %110, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %119 = llvm.inttoptr %115 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %120 = llvm.inttoptr %118 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%119, %120, %117) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %121 = arith.addi %115, %117 : i256 loc(#loc1) +// CHECK-NEXT: %122 = llvm.inttoptr %121 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %122 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %123 = llvm.inttoptr %113 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %117, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %124 = arith.addi %117, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %125 = arith.andi %124, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %126 = arith.addi %115, %125 : i256 loc(#loc1) +// CHECK-NEXT: %127 = arith.subi %126, %112 : i256 loc(#loc1) +// CHECK-NEXT: %128 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%128, %127) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -560,446 +653,511 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %134 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%134, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%153, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %134 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%134, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%153, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c100_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi ugt, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %20 = arith.addi %19, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %24 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %25 = arith.addi %13, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %19, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %25 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.cmpi ugt, %28, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %29 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %19 : i256 loc(#loc1) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %154 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%155, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %15, %28 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.addi %30, %c192_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %1 : i256 loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %13, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %19, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %32 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %34, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %30 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %30, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %34, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %40 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %30, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %34, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %45 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.cmpi ugt, %48, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %49 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %15, %31 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %33, %c192_i256 : i256 loc(#loc1) +// CHECK-NEXT: %35 = arith.cmpi ugt, %34, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %35 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401470520153988868949248340840_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50408947360703532628410820127875489391510599906502180640049823775688402927616_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %30, %48 : i256 loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %50, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %52 = arith.cmpi sge, %51, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %52 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %38 = arith.addi %37, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.cmpi ugt, %38, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %40 = arith.cmpi ult, %38, %37 : i256 loc(#loc1) +// CHECK-NEXT: %41 = arith.ori %39, %40 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %41 { +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %154 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%155, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %50 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %38, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %33 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %44, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %33, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %37, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %46 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %50 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %49, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %33, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %37, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %51 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %50, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = arith.addi %55, %54 : i256 loc(#loc1) -// CHECK-NEXT: %57 = arith.cmpi ugt, %56, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %57 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %55 = arith.cmpi ugt, %54, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %54, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %59 = arith.andi %58, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = arith.cmpi ugt, %54, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %60 { -// CHECK-NEXT: %134 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%136, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %33, %54 : i256 loc(#loc1) +// CHECK-NEXT: %57 = arith.addi %56, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.cmpi sge, %57, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %58 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %59, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.load %62 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %64 = arith.addi %63, %61 : i256 loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %64, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %54, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %63, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = llvm.inttoptr %55 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%68, %69, %54) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %70 = arith.addi %67, %54 : i256 loc(#loc1) -// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %72 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %63, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = arith.addi %30, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %74 = arith.addi %34, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %30, %c127_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = arith.cmpi sge, %75, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %76 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %56 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %60 = llvm.load %59 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %56, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %61, %60 : i256 loc(#loc1) +// CHECK-NEXT: %63 = arith.cmpi ugt, %62, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %63 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %77 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %78 = llvm.load %77 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %78, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %79, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %30, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = arith.cmpi ugt, %81, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %82 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %64 = arith.addi %60, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %65 = arith.andi %64, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.cmpi ugt, %60, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %66 { +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %154 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%155, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %83:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %78, %arg2 = %73) -> (i256, i256) { -// CHECK-NEXT: %134 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %135, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %137, %138 : i256, i256 loc(#loc1) +// CHECK-NEXT: %67 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %65, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = arith.andi %69, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %71 = arith.addi %68, %70 : i256 loc(#loc1) +// CHECK-NEXT: %72 = arith.cmpi ugt, %71, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %73 = arith.cmpi ult, %71, %68 : i256 loc(#loc1) +// CHECK-NEXT: %74 = arith.ori %72, %73 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %74 { +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %154 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%155, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %78, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %85 = arith.addi %30, %c160_i256 : i256 loc(#loc1) -// CHECK-NEXT: %86 = arith.addi %34, %c128_i256 : i256 loc(#loc1) -// CHECK-NEXT: %87 = llvm.inttoptr %85 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %89 = arith.cmpi ugt, %88, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %89 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %71, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %60, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %77 = arith.addi %68, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %79 = llvm.inttoptr %61 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%78, %79, %60) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %80 = arith.addi %77, %60 : i256 loc(#loc1) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %82 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %68, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %83 = arith.addi %33, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %84 = arith.addi %37, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %85 = arith.addi %33, %c127_i256 : i256 loc(#loc1) +// CHECK-NEXT: %86 = arith.cmpi sge, %85, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %86 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %90 = arith.addi %30, %88 : i256 loc(#loc1) -// CHECK-NEXT: %91 = arith.addi %90, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %92 = arith.cmpi sge, %91, %1 : i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %89 = arith.addi %88, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %90 = arith.cmpi ugt, %89, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = arith.cmpi ult, %89, %88 : i256 loc(#loc1) +// CHECK-NEXT: %92 = arith.ori %90, %91 : i1 loc(#loc1) // CHECK-NEXT: scf.if %92 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %154 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%155, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %89, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %33, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = arith.cmpi ugt, %94, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %95 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %93 = llvm.inttoptr %90 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %95 = arith.addi %90, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %96 = arith.muli %94, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %97 = arith.addi %95, %96 : i256 loc(#loc1) -// CHECK-NEXT: %98 = arith.cmpi ugt, %97, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %98 { -// CHECK-NEXT: %134 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %135, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %139 = arith.addi %135, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %140 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %140 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %141 = arith.addi %135, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %143 = arith.addi %135, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %144 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %145 = llvm.inttoptr %135 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%145, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %96:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %88, %arg2 = %83) -> (i256, i256) { +// CHECK-NEXT: %153 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %154, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %156, %157 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %97 = llvm.inttoptr %84 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %88, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %98 = arith.addi %33, %c160_i256 : i256 loc(#loc1) +// CHECK-NEXT: %99 = arith.addi %37, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: %100 = llvm.inttoptr %98 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %101 = llvm.load %100 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %102 = arith.cmpi ugt, %101, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %102 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481743997880166685973898854_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c52195229743194479185619533901126580011012186126243431406710767645195241521152_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %99 = arith.muli %94, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %100 = arith.cmpi ugt, %94, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %100 { -// CHECK-NEXT: %134 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %134 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %135 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %135 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%136, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %103 = arith.addi %33, %101 : i256 loc(#loc1) +// CHECK-NEXT: %104 = arith.addi %103, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %105 = arith.cmpi sge, %104, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %105 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %101 = arith.addi %99, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %102 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %103 = llvm.load %102 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %104 = arith.addi %103, %101 : i256 loc(#loc1) -// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %104, %105 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %106 = llvm.inttoptr %103 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %94, %106 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %107 = arith.addi %103, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %108 = arith.index_castui %94 : i256 to index loc(#loc1) -// CHECK-NEXT: %109:2 = scf.for %arg0 = %c0 to %108 step %c1 iter_args(%arg1 = %107, %arg2 = %95) -> (i256, i256) { -// CHECK-NEXT: %134 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %135 = llvm.load %134 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %136 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %135, %136 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %137 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %138 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %137, %138 : i256, i256 loc(#loc1) +// CHECK-NEXT: %106 = llvm.inttoptr %103 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %107 = llvm.load %106 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %108 = arith.addi %103, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %109 = arith.muli %107, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %110 = arith.addi %108, %109 : i256 loc(#loc1) +// CHECK-NEXT: %111 = arith.cmpi ugt, %110, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %111 { +// CHECK-NEXT: %153 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %154, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = llvm.inttoptr %156 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %157 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %158 = arith.addi %154, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %159 = llvm.inttoptr %158 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %159 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %160 = arith.addi %154, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %161 = llvm.inttoptr %160 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %161 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %162 = arith.addi %154, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %163 = llvm.inttoptr %162 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %163 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %164 = llvm.inttoptr %154 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%164, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %110 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %103, %110 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %111 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %34, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %112 = arith.addi %13, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %113 = arith.addi %19, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %114 = llvm.inttoptr %112 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %115 = llvm.load %114 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %116 = llvm.inttoptr %113 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %115, %116 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %117 = func.call @mem_nested_83(%19) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %118 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %119 = llvm.load %118 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %120 = arith.addi %119, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %121 = llvm.inttoptr %119 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %122 = arith.addi %119, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %123 = llvm.inttoptr %117 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %124 = llvm.load %123 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %125 = arith.addi %117, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %126 = llvm.inttoptr %122 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %127 = llvm.inttoptr %125 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%126, %127, %124) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %128 = llvm.inttoptr %120 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %124, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %129 = arith.addi %124, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %130 = arith.andi %129, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %131 = arith.addi %122, %130 : i256 loc(#loc1) -// CHECK-NEXT: %132 = arith.subi %131, %119 : i256 loc(#loc1) -// CHECK-NEXT: %133 = llvm.inttoptr %119 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%133, %132) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %112 = arith.muli %107, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %113 = arith.cmpi ugt, %107, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %113 { +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %154 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%155, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %114 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %115 = llvm.load %114 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %116 = arith.addi %112, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %117 = arith.andi %116, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %118 = arith.addi %115, %117 : i256 loc(#loc1) +// CHECK-NEXT: %119 = arith.cmpi ugt, %118, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %120 = arith.cmpi ult, %118, %115 : i256 loc(#loc1) +// CHECK-NEXT: %121 = arith.ori %119, %120 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %121 { +// CHECK-NEXT: %153 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %153 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %154 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %154 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%155, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %122 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %118, %122 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %123 = llvm.inttoptr %115 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %107, %123 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %124 = arith.addi %115, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %125 = arith.index_castui %107 : i256 to index loc(#loc1) +// CHECK-NEXT: %126:2 = scf.for %arg0 = %c0 to %125 step %c1 iter_args(%arg1 = %124, %arg2 = %108) -> (i256, i256) { +// CHECK-NEXT: %153 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %154 = llvm.load %153 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %155 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %154, %155 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %156 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %157 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %156, %157 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %127 = llvm.inttoptr %99 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %115, %127 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %128 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %37, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %129 = arith.addi %13, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %130 = arith.addi %19, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %131 = llvm.inttoptr %129 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %132 = llvm.load %131 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %133 = llvm.inttoptr %130 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %132, %133 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %134 = func.call @mem_nested_94(%19) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %135 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %136 = llvm.load %135 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %137 = arith.addi %136, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %138 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %138 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %139 = arith.addi %136, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %140 = llvm.inttoptr %134 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %141 = llvm.load %140 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %142 = arith.addi %134, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %143 = llvm.inttoptr %139 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %144 = llvm.inttoptr %142 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%143, %144, %141) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %145 = arith.addi %139, %141 : i256 loc(#loc1) +// CHECK-NEXT: %146 = llvm.inttoptr %145 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %146 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %147 = llvm.inttoptr %137 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %141, %147 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %148 = arith.addi %141, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %149 = arith.andi %148, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %150 = arith.addi %139, %149 : i256 loc(#loc1) +// CHECK-NEXT: %151 = arith.subi %150, %136 : i256 loc(#loc1) +// CHECK-NEXT: %152 = llvm.inttoptr %136 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%152, %151) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1007,66 +1165,66 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%35, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%37, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%35, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%37, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %36, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %36, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %38, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %36, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %38, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %36, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %38, %c68_i256 : i256 loc(#loc1) // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%46, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c196_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi ugt, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %36, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %36, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %38, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %36, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %38, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401469311081407054693749781615_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %36, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %38, %c68_i256 : i256 loc(#loc1) // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50264061815216559366394377081970557408421897885763683796495622118736499048448_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%46, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401469311081407054693749781615_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50264061815216559366394377081970557408421897885763683796495622118736499048448_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %18 = func.call @cd_big_97(%15) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %18 = func.call @cd_big_108(%15) : (i256) -> i256 loc(#loc1) // CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %21 = arith.addi %20, %c32_i256 : i256 loc(#loc1) @@ -1079,14 +1237,17 @@ contract C { // CHECK-NEXT: %27 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %28 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%27, %28, %25) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %29 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %25, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.andi %30, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %23, %31 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.subi %32, %20 : i256 loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%34, %33) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %23, %25 : i256 loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %25, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = arith.addi %25, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.andi %32, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %23, %33 : i256 loc(#loc1) +// CHECK-NEXT: %35 = arith.subi %34, %20 : i256 loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%36, %35) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1094,66 +1255,66 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%35, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%37, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%35, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%37, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %36, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %36, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %38, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %36, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %38, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %36, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %38, %c68_i256 : i256 loc(#loc1) // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%46, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c100_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi ugt, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %36, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %36, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %38, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %36, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %38, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401469311081407054693749781615_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %36, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %38, %c68_i256 : i256 loc(#loc1) // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c50264061815216559366394377081970557408421897885763683796495622118736499048448_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%46, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373660511553963533401469311081407054693749781615_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c50264061815216559366394377081970557408421897885763683796495622118736499048448_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %18 = func.call @cd_nested_111(%15) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %18 = func.call @cd_nested_122(%15) : (i256) -> i256 loc(#loc1) // CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %21 = arith.addi %20, %c32_i256 : i256 loc(#loc1) @@ -1166,14 +1327,151 @@ contract C { // CHECK-NEXT: %27 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %28 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%27, %28, %25) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %29 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %25, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.andi %30, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %23, %31 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.subi %32, %20 : i256 loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%34, %33) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %23, %25 : i256 loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %25, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = arith.addi %25, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.andi %32, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %23, %33 : i256 loc(#loc1) +// CHECK-NEXT: %35 = arith.subi %34, %20 : i256 loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%36, %35) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case -1956714727 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi slt, %10, %c128_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %1, %c132_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = arith.addi %33, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %37 = arith.addi %33, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %33, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = arith.addi %33, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%43, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %13 = func.call @enc_struct_138(%c4_i256) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %16 = arith.addi %15, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %15, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %13, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%22, %23, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %18, %20 : i256 loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %20, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.andi %27, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %18, %28 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.subi %29, %15 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%31, %30) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 1823923966 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @storage_big_149() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: scf.yield loc(#loc1) +// CHECK-NEXT: } +// CHECK-NEXT: case 1976810528 { +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %10 = func.call @storage_big_nested_160() : () -> i256 loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %12, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %10, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1181,11 +1479,11 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %10 = func.call @storage_flat_122() : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = func.call @storage_flat_171() : () -> i256 loc(#loc1) // CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) @@ -1198,14 +1496,17 @@ contract C { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1213,11 +1514,11 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %10 = func.call @storage_nested_133() : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = func.call @storage_nested_182() : () -> i256 loc(#loc1) // CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) @@ -1230,14 +1531,17 @@ contract C { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1245,11 +1549,11 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %10 = func.call @storage_packed_144() : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = func.call @storage_packed_193() : () -> i256 loc(#loc1) // CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) @@ -1262,14 +1566,17 @@ contract C { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1282,22 +1589,27 @@ contract C { // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: func.func @storage_packed_144() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c9_i256 = arith.constant 9 : i256 loc(#loc) +// CHECK-NEXT: func.func @storage_packed_193() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c23_i256 = arith.constant 23 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c255_i256 = arith.constant 255 : i256 loc(#loc) // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc3) +// CHECK-NEXT: %c22_i256 = arith.constant 22 : i256 loc(#loc3) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc4) // CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc4) // CHECK-NEXT: %3 = arith.addi %1, %c160_i256 : i256 loc(#loc4) -// CHECK-NEXT: %4 = llvm.inttoptr %c8_i256 : i256 to !llvm.ptr<5> loc(#loc4) +// CHECK-NEXT: %4 = llvm.inttoptr %c22_i256 : i256 to !llvm.ptr<5> loc(#loc4) // CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc4) // CHECK-NEXT: %6 = arith.trunci %5 : i256 to i128 loc(#loc4) // CHECK-NEXT: %7 = arith.extui %6 : i128 to i256 loc(#loc4) @@ -1317,7 +1629,7 @@ contract C { // CHECK-NEXT: %19 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: %20 = arith.addi %1, %c128_i256 : i256 loc(#loc4) -// CHECK-NEXT: %21 = llvm.inttoptr %c9_i256 : i256 to !llvm.ptr<5> loc(#loc4) +// CHECK-NEXT: %21 = llvm.inttoptr %c23_i256 : i256 to !llvm.ptr<5> loc(#loc4) // CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc4) // CHECK-NEXT: %23 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) @@ -1325,21 +1637,36 @@ contract C { // CHECK-NEXT: %25 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: %26 = arith.addi %1, %c160_i256 : i256 loc(#loc4) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %27 = arith.cmpi ugt, %26, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %28 = arith.cmpi ult, %26, %1 : i256 loc(#loc4) +// CHECK-NEXT: %29 = arith.ori %27, %28 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %32 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%33, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %26, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: return %1 : i256 loc(#loc5) // CHECK-NEXT: } loc(#loc2) -// CHECK-NEXT: func.func @storage_nested_133() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c7_i256 = arith.constant 7 : i256 loc(#loc) +// CHECK-NEXT: func.func @storage_nested_182() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c21_i256 = arith.constant 21 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c288_i256 = arith.constant 288 : i256 loc(#loc) -// CHECK-NEXT: %c6_i256 = arith.constant 6 : i256 loc(#loc) +// CHECK-NEXT: %c20_i256 = arith.constant 20 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) -// CHECK-NEXT: %c5_i256 = arith.constant 5 : i256 loc(#loc) +// CHECK-NEXT: %c19_i256 = arith.constant 19 : i256 loc(#loc) // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) // CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) +// CHECK-NEXT: %c18_i256 = arith.constant 18 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -1353,7 +1680,7 @@ contract C { // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 loc(#loc7) +// CHECK-NEXT: %c17_i256 = arith.constant 17 : i256 loc(#loc7) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc8) @@ -1363,7 +1690,7 @@ contract C { // CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: %6 = arith.addi %1, %c160_i256 : i256 loc(#loc8) -// CHECK-NEXT: %7 = llvm.inttoptr %c3_i256 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %7 = llvm.inttoptr %c17_i256 : i256 to !llvm.ptr<5> loc(#loc8) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) // CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) @@ -1372,12 +1699,12 @@ contract C { // CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: %13 = arith.addi %1, %c256_i256 : i256 loc(#loc8) -// CHECK-NEXT: %14 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %14 = llvm.inttoptr %c18_i256 : i256 to !llvm.ptr<5> loc(#loc8) // CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) // CHECK-NEXT: %16 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: %17 = arith.addi %1, %c192_i256 : i256 loc(#loc8) -// CHECK-NEXT: %18 = llvm.inttoptr %c5_i256 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %18 = llvm.inttoptr %c19_i256 : i256 to !llvm.ptr<5> loc(#loc8) // CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) // CHECK-NEXT: %20 = arith.trunci %19 : i256 to i128 loc(#loc8) // CHECK-NEXT: %21 = arith.extui %20 : i128 to i256 loc(#loc8) @@ -1388,7 +1715,7 @@ contract C { // CHECK-NEXT: %25 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: %26 = arith.addi %1, %c288_i256 : i256 loc(#loc8) -// CHECK-NEXT: %27 = llvm.inttoptr %c6_i256 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %27 = llvm.inttoptr %c20_i256 : i256 to !llvm.ptr<5> loc(#loc8) // CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) // CHECK-NEXT: %29 = arith.shrui %28, %c1_i256 : i256 loc(#loc8) // CHECK-NEXT: %30 = arith.andi %28, %c1_i256 : i256 loc(#loc8) @@ -1399,35 +1726,35 @@ contract C { // CHECK-NEXT: %35 = arith.trunci %30 : i256 to i1 loc(#loc8) // CHECK-NEXT: %36 = arith.cmpi eq, %35, %34 : i1 loc(#loc8) // CHECK-NEXT: scf.if %36 { -// CHECK-NEXT: %50 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %51 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %c34_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: "llvm.intrcall"(%52, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: %57 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %58 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c34_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %59 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%59, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: %37 = arith.andi %28, %c1_i256 : i256 loc(#loc8) // CHECK-NEXT: %38 = arith.cmpi eq, %37, %c0_i256 : i256 loc(#loc8) // CHECK-NEXT: scf.if %38 { -// CHECK-NEXT: %50 = arith.andi %28, %c-256_i256 : i256 loc(#loc8) -// CHECK-NEXT: %51 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %50, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %57 = arith.andi %28, %c-256_i256 : i256 loc(#loc8) +// CHECK-NEXT: %58 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: } else { -// CHECK-NEXT: %50 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %c6_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %51 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %52 = "llvm.intrcall"(%51, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc8) -// CHECK-NEXT: %53 = arith.index_castui %33 : i256 to index loc(#loc8) -// CHECK-NEXT: scf.for %arg0 = %c0 to %53 step %c32 { -// CHECK-NEXT: %54 = arith.index_castui %arg0 : index to i256 loc(#loc8) -// CHECK-NEXT: %55 = arith.divui %54, %c32_i256 : i256 loc(#loc8) -// CHECK-NEXT: %56 = arith.addi %52, %55 : i256 loc(#loc8) -// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<5> loc(#loc8) -// CHECK-NEXT: %58 = llvm.load %57 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) -// CHECK-NEXT: %59 = arith.addi %26, %54 : i256 loc(#loc8) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %58, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %57 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c20_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %59 = "llvm.intrcall"(%58, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc8) +// CHECK-NEXT: %60 = arith.index_castui %33 : i256 to index loc(#loc8) +// CHECK-NEXT: scf.for %arg0 = %c0 to %60 step %c32 { +// CHECK-NEXT: %61 = arith.index_castui %arg0 : index to i256 loc(#loc8) +// CHECK-NEXT: %62 = arith.divui %61, %c32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %63 = arith.addi %59, %62 : i256 loc(#loc8) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) +// CHECK-NEXT: %66 = arith.addi %26, %61 : i256 loc(#loc8) +// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %65, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: %39 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc8) @@ -1436,23 +1763,42 @@ contract C { // CHECK-NEXT: %41 = arith.andi %40, %c-32_i256 : i256 loc(#loc8) // CHECK-NEXT: %42 = arith.addi %26, %41 : i256 loc(#loc8) // CHECK-NEXT: %43 = arith.addi %1, %c128_i256 : i256 loc(#loc8) -// CHECK-NEXT: %44 = llvm.inttoptr %c7_i256 : i256 to !llvm.ptr<5> loc(#loc8) +// CHECK-NEXT: %44 = llvm.inttoptr %c21_i256 : i256 to !llvm.ptr<5> loc(#loc8) // CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc8) // CHECK-NEXT: %46 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: llvm.store %45, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: %47 = arith.subi %42, %2 : i256 loc(#loc8) // CHECK-NEXT: %48 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: llvm.store %47, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %42, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %49 = arith.subi %42, %1 : i256 loc(#loc8) +// CHECK-NEXT: %50 = arith.addi %49, %c31_i256 : i256 loc(#loc8) +// CHECK-NEXT: %51 = arith.andi %50, %c-32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %52 = arith.addi %1, %51 : i256 loc(#loc8) +// CHECK-NEXT: %53 = arith.cmpi ugt, %52, %c18446744073709551615_i256 : i256 loc(#loc8) +// CHECK-NEXT: %54 = arith.cmpi ult, %52, %1 : i256 loc(#loc8) +// CHECK-NEXT: %55 = arith.ori %53, %54 : i1 loc(#loc8) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %57 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %58 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c65_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %59 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%59, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %52, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) // CHECK-NEXT: return %1 : i256 loc(#loc9) // CHECK-NEXT: } loc(#loc6) -// CHECK-NEXT: func.func @storage_flat_122() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @storage_flat_171() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c16_i256 = arith.constant 16 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c15_i256 = arith.constant 15 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -1464,380 +1810,824 @@ contract C { // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c127_i256 = arith.constant 127 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c14_i256 = arith.constant 14 : i256 loc(#loc11) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc11) -// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc11) -// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc11) -// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %6 = arith.addi %1, %c160_i256 : i256 loc(#loc11) -// CHECK-NEXT: %7 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc11) -// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc11) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc11) -// CHECK-NEXT: %11 = llvm.inttoptr %c1_i256 : i256 to !llvm.ptr<5> loc(#loc11) -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc11) -// CHECK-NEXT: %13 = arith.trunci %12 : i256 to i128 loc(#loc11) -// CHECK-NEXT: %14 = arith.extui %13 : i128 to i256 loc(#loc11) -// CHECK-NEXT: %15 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %16 = arith.addi %1, %c128_i256 : i256 loc(#loc11) -// CHECK-NEXT: %17 = arith.subi %6, %3 : i256 loc(#loc11) -// CHECK-NEXT: %18 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %19 = arith.addi %1, %c192_i256 : i256 loc(#loc11) -// CHECK-NEXT: %20 = llvm.inttoptr %c2_i256 : i256 to !llvm.ptr<5> loc(#loc11) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc11) -// CHECK-NEXT: %22 = arith.shrui %21, %c1_i256 : i256 loc(#loc11) -// CHECK-NEXT: %23 = arith.andi %21, %c1_i256 : i256 loc(#loc11) -// CHECK-NEXT: %24 = arith.cmpi eq, %23, %c0_i256 : i256 loc(#loc11) -// CHECK-NEXT: %25 = arith.andi %22, %c127_i256 : i256 loc(#loc11) -// CHECK-NEXT: %26 = arith.select %24, %25, %22 : i256 loc(#loc11) -// CHECK-NEXT: %27 = arith.cmpi ult, %26, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %28 = arith.trunci %23 : i256 to i1 loc(#loc11) -// CHECK-NEXT: %29 = arith.cmpi eq, %28, %27 : i1 loc(#loc11) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc12) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc12) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc12) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %6 = arith.addi %1, %c160_i256 : i256 loc(#loc12) +// CHECK-NEXT: %7 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc12) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc12) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc12) +// CHECK-NEXT: %11 = llvm.inttoptr %c15_i256 : i256 to !llvm.ptr<5> loc(#loc12) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc12) +// CHECK-NEXT: %13 = arith.trunci %12 : i256 to i128 loc(#loc12) +// CHECK-NEXT: %14 = arith.extui %13 : i128 to i256 loc(#loc12) +// CHECK-NEXT: %15 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %16 = arith.addi %1, %c128_i256 : i256 loc(#loc12) +// CHECK-NEXT: %17 = arith.subi %6, %3 : i256 loc(#loc12) +// CHECK-NEXT: %18 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %19 = arith.addi %1, %c192_i256 : i256 loc(#loc12) +// CHECK-NEXT: %20 = llvm.inttoptr %c16_i256 : i256 to !llvm.ptr<5> loc(#loc12) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc12) +// CHECK-NEXT: %22 = arith.shrui %21, %c1_i256 : i256 loc(#loc12) +// CHECK-NEXT: %23 = arith.andi %21, %c1_i256 : i256 loc(#loc12) +// CHECK-NEXT: %24 = arith.cmpi eq, %23, %c0_i256 : i256 loc(#loc12) +// CHECK-NEXT: %25 = arith.andi %22, %c127_i256 : i256 loc(#loc12) +// CHECK-NEXT: %26 = arith.select %24, %25, %22 : i256 loc(#loc12) +// CHECK-NEXT: %27 = arith.cmpi ult, %26, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %28 = arith.trunci %23 : i256 to i1 loc(#loc12) +// CHECK-NEXT: %29 = arith.cmpi eq, %28, %27 : i1 loc(#loc12) // CHECK-NEXT: scf.if %29 { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %40 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: "llvm.intrcall"(%41, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc11) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc11) -// CHECK-NEXT: } loc(#loc11) -// CHECK-NEXT: %30 = arith.andi %21, %c1_i256 : i256 loc(#loc11) -// CHECK-NEXT: %31 = arith.cmpi eq, %30, %c0_i256 : i256 loc(#loc11) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c34_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc12) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %30 = arith.andi %21, %c1_i256 : i256 loc(#loc12) +// CHECK-NEXT: %31 = arith.cmpi eq, %30, %c0_i256 : i256 loc(#loc12) // CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %39 = arith.andi %21, %c-256_i256 : i256 loc(#loc11) -// CHECK-NEXT: %40 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %46 = arith.andi %21, %c-256_i256 : i256 loc(#loc12) +// CHECK-NEXT: %47 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %46, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) // CHECK-NEXT: } else { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %c2_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %41 = "llvm.intrcall"(%40, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc11) -// CHECK-NEXT: %42 = arith.index_castui %26 : i256 to index loc(#loc11) -// CHECK-NEXT: scf.for %arg0 = %c0 to %42 step %c32 { -// CHECK-NEXT: %43 = arith.index_castui %arg0 : index to i256 loc(#loc11) -// CHECK-NEXT: %44 = arith.divui %43, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %45 = arith.addi %41, %44 : i256 loc(#loc11) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<5> loc(#loc11) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc11) -// CHECK-NEXT: %48 = arith.addi %19, %43 : i256 loc(#loc11) -// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %47, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: } loc(#loc11) -// CHECK-NEXT: } loc(#loc11) -// CHECK-NEXT: %32 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %26, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %33 = arith.addi %26, %c31_i256 : i256 loc(#loc11) -// CHECK-NEXT: %34 = arith.andi %33, %c-32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %35 = arith.addi %19, %34 : i256 loc(#loc11) -// CHECK-NEXT: %36 = arith.subi %35, %2 : i256 loc(#loc11) -// CHECK-NEXT: %37 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %36, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %35, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: return %1 : i256 loc(#loc12) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c16_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %48 = "llvm.intrcall"(%47, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc12) +// CHECK-NEXT: %49 = arith.index_castui %26 : i256 to index loc(#loc12) +// CHECK-NEXT: scf.for %arg0 = %c0 to %49 step %c32 { +// CHECK-NEXT: %50 = arith.index_castui %arg0 : index to i256 loc(#loc12) +// CHECK-NEXT: %51 = arith.divui %50, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %52 = arith.addi %48, %51 : i256 loc(#loc12) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<5> loc(#loc12) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc12) +// CHECK-NEXT: %55 = arith.addi %19, %50 : i256 loc(#loc12) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %54, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %32 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %26, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %33 = arith.addi %26, %c31_i256 : i256 loc(#loc12) +// CHECK-NEXT: %34 = arith.andi %33, %c-32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %35 = arith.addi %19, %34 : i256 loc(#loc12) +// CHECK-NEXT: %36 = arith.subi %35, %2 : i256 loc(#loc12) +// CHECK-NEXT: %37 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %36, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %38 = arith.subi %35, %1 : i256 loc(#loc12) +// CHECK-NEXT: %39 = arith.addi %38, %c31_i256 : i256 loc(#loc12) +// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %41 = arith.addi %1, %40 : i256 loc(#loc12) +// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc12) +// CHECK-NEXT: %43 = arith.cmpi ult, %41, %1 : i256 loc(#loc12) +// CHECK-NEXT: %44 = arith.ori %42, %43 : i1 loc(#loc12) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc12) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %41, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: return %1 : i256 loc(#loc13) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: func.func @cd_nested_111(%arg0: i256 loc({{.*}}:54:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @storage_big_nested_160() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c13_i256 = arith.constant 13 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c12_i256 = arith.constant 12 : i256 loc(#loc) // CHECK-NEXT: %c320_i256 = arith.constant 320 : i256 loc(#loc) +// CHECK-NEXT: %c10_i256 = arith.constant 10 : i256 loc(#loc) // CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) // CHECK-NEXT: %c384_i256 = arith.constant 384 : i256 loc(#loc) +// CHECK-NEXT: %c9_i256 = arith.constant 9 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) // CHECK-NEXT: %c352_i256 = arith.constant 352 : i256 loc(#loc) -// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) -// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c7_i256 = arith.constant 7 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c127_i256 = arith.constant 127 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c6_i256 = arith.constant 6 : i256 loc(#loc15) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc16) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc16) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %6 = arith.addi %1, %c160_i256 : i256 loc(#loc16) +// CHECK-NEXT: %7 = llvm.inttoptr %c6_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc16) +// CHECK-NEXT: %11 = arith.subi %6, %3 : i256 loc(#loc16) +// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %13 = arith.addi %1, %c352_i256 : i256 loc(#loc16) +// CHECK-NEXT: %14 = llvm.inttoptr %c7_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %16 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %17 = arith.addi %1, %c192_i256 : i256 loc(#loc16) +// CHECK-NEXT: %18 = llvm.inttoptr %c8_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %21 = arith.addi %1, %c224_i256 : i256 loc(#loc16) +// CHECK-NEXT: %22 = arith.subi %13, %6 : i256 loc(#loc16) +// CHECK-NEXT: %23 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %24 = arith.addi %1, %c384_i256 : i256 loc(#loc16) +// CHECK-NEXT: %25 = llvm.inttoptr %c9_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %27 = arith.shrui %26, %c1_i256 : i256 loc(#loc16) +// CHECK-NEXT: %28 = arith.andi %26, %c1_i256 : i256 loc(#loc16) +// CHECK-NEXT: %29 = arith.cmpi eq, %28, %c0_i256 : i256 loc(#loc16) +// CHECK-NEXT: %30 = arith.andi %27, %c127_i256 : i256 loc(#loc16) +// CHECK-NEXT: %31 = arith.select %29, %30, %27 : i256 loc(#loc16) +// CHECK-NEXT: %32 = arith.cmpi ult, %31, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %33 = arith.trunci %28 : i256 to i1 loc(#loc16) +// CHECK-NEXT: %34 = arith.cmpi eq, %33, %32 : i1 loc(#loc16) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c34_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %35 = arith.andi %26, %c1_i256 : i256 loc(#loc16) +// CHECK-NEXT: %36 = arith.cmpi eq, %35, %c0_i256 : i256 loc(#loc16) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %71 = arith.andi %26, %c-256_i256 : i256 loc(#loc16) +// CHECK-NEXT: %72 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %71, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: } else { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c9_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %72 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %73 = "llvm.intrcall"(%72, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc16) +// CHECK-NEXT: %74 = arith.index_castui %31 : i256 to index loc(#loc16) +// CHECK-NEXT: scf.for %arg0 = %c0 to %74 step %c32 { +// CHECK-NEXT: %75 = arith.index_castui %arg0 : index to i256 loc(#loc16) +// CHECK-NEXT: %76 = arith.divui %75, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %77 = arith.addi %73, %76 : i256 loc(#loc16) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %79 = llvm.load %78 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %80 = arith.addi %24, %75 : i256 loc(#loc16) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %79, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %37 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %31, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %38 = arith.addi %31, %c31_i256 : i256 loc(#loc16) +// CHECK-NEXT: %39 = arith.andi %38, %c-32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %40 = arith.addi %24, %39 : i256 loc(#loc16) +// CHECK-NEXT: %41 = arith.addi %1, %c256_i256 : i256 loc(#loc16) +// CHECK-NEXT: %42:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %41, %arg2 = %c10_i256) -> (i256, i256) { +// CHECK-NEXT: %71 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %73 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %72, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %74 = arith.addi %arg1, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %75 = arith.addi %arg2, %c1_i256 : i256 loc(#loc16) +// CHECK-NEXT: scf.yield %74, %75 : i256, i256 loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %43 = arith.addi %1, %c320_i256 : i256 loc(#loc16) +// CHECK-NEXT: %44 = arith.subi %40, %6 : i256 loc(#loc16) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %44, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %46 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %48 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %47, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %49 = arith.index_castui %47 : i256 to index loc(#loc16) +// CHECK-NEXT: %50 = arith.addi %40, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %51 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c12_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %53 = "llvm.intrcall"(%52, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc16) +// CHECK-NEXT: %54 = arith.muli %47, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %55 = arith.addi %50, %54 : i256 loc(#loc16) +// CHECK-NEXT: %56:2 = scf.for %arg0 = %c0 to %49 step %c1 iter_args(%arg1 = %50, %arg2 = %53) -> (i256, i256) { +// CHECK-NEXT: %71 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %73 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %72, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %74 = arith.addi %arg1, %c32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %75 = arith.addi %arg2, %c1_i256 : i256 loc(#loc16) +// CHECK-NEXT: scf.yield %74, %75 : i256, i256 loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %57 = arith.addi %1, %c128_i256 : i256 loc(#loc16) +// CHECK-NEXT: %58 = llvm.inttoptr %c13_i256 : i256 to !llvm.ptr<5> loc(#loc16) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc16) +// CHECK-NEXT: %60 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %59, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %61 = arith.subi %55, %2 : i256 loc(#loc16) +// CHECK-NEXT: %62 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %61, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %63 = arith.subi %55, %1 : i256 loc(#loc16) +// CHECK-NEXT: %64 = arith.addi %63, %c31_i256 : i256 loc(#loc16) +// CHECK-NEXT: %65 = arith.andi %64, %c-32_i256 : i256 loc(#loc16) +// CHECK-NEXT: %66 = arith.addi %1, %65 : i256 loc(#loc16) +// CHECK-NEXT: %67 = arith.cmpi ugt, %66, %c18446744073709551615_i256 : i256 loc(#loc16) +// CHECK-NEXT: %68 = arith.cmpi ult, %66, %1 : i256 loc(#loc16) +// CHECK-NEXT: %69 = arith.ori %67, %68 : i1 loc(#loc16) +// CHECK-NEXT: scf.if %69 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %c65_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) +// CHECK-NEXT: } loc(#loc16) +// CHECK-NEXT: %70 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: llvm.store %66, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) +// CHECK-NEXT: return %1 : i256 loc(#loc17) +// CHECK-NEXT: } loc(#loc14) +// CHECK-NEXT: func.func @storage_big_149() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c5_i256 = arith.constant 5 : i256 loc(#loc) +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 loc(#loc) +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c288_i256 = arith.constant 288 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c127_i256 = arith.constant 127 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc19) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %3 = arith.addi %1, %c64_i256 : i256 loc(#loc19) +// CHECK-NEXT: %4 = arith.subi %3, %2 : i256 loc(#loc19) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %6 = arith.addi %1, %c256_i256 : i256 loc(#loc19) +// CHECK-NEXT: %7 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc19) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc19) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %10 = arith.addi %1, %c96_i256 : i256 loc(#loc19) +// CHECK-NEXT: %11 = llvm.inttoptr %c1_i256 : i256 to !llvm.ptr<5> loc(#loc19) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc19) +// CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %14 = arith.addi %1, %c128_i256 : i256 loc(#loc19) +// CHECK-NEXT: %15 = arith.subi %6, %3 : i256 loc(#loc19) +// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %17 = arith.addi %1, %c288_i256 : i256 loc(#loc19) +// CHECK-NEXT: %18 = llvm.inttoptr %c2_i256 : i256 to !llvm.ptr<5> loc(#loc19) +// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc19) +// CHECK-NEXT: %20 = arith.shrui %19, %c1_i256 : i256 loc(#loc19) +// CHECK-NEXT: %21 = arith.andi %19, %c1_i256 : i256 loc(#loc19) +// CHECK-NEXT: %22 = arith.cmpi eq, %21, %c0_i256 : i256 loc(#loc19) +// CHECK-NEXT: %23 = arith.andi %20, %c127_i256 : i256 loc(#loc19) +// CHECK-NEXT: %24 = arith.select %22, %23, %20 : i256 loc(#loc19) +// CHECK-NEXT: %25 = arith.cmpi ult, %24, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %26 = arith.trunci %21 : i256 to i1 loc(#loc19) +// CHECK-NEXT: %27 = arith.cmpi eq, %26, %25 : i1 loc(#loc19) +// CHECK-NEXT: scf.if %27 { +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %61 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c34_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: "llvm.intrcall"(%62, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc19) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %28 = arith.andi %19, %c1_i256 : i256 loc(#loc19) +// CHECK-NEXT: %29 = arith.cmpi eq, %28, %c0_i256 : i256 loc(#loc19) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %60 = arith.andi %19, %c-256_i256 : i256 loc(#loc19) +// CHECK-NEXT: %61 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %60, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: } else { +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c2_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %61 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %62 = "llvm.intrcall"(%61, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc19) +// CHECK-NEXT: %63 = arith.index_castui %24 : i256 to index loc(#loc19) +// CHECK-NEXT: scf.for %arg0 = %c0 to %63 step %c32 { +// CHECK-NEXT: %64 = arith.index_castui %arg0 : index to i256 loc(#loc19) +// CHECK-NEXT: %65 = arith.divui %64, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %66 = arith.addi %62, %65 : i256 loc(#loc19) +// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<5> loc(#loc19) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc19) +// CHECK-NEXT: %69 = arith.addi %17, %64 : i256 loc(#loc19) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %68, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %30 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %24, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %31 = arith.addi %24, %c31_i256 : i256 loc(#loc19) +// CHECK-NEXT: %32 = arith.andi %31, %c-32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %33 = arith.addi %17, %32 : i256 loc(#loc19) +// CHECK-NEXT: %34 = arith.addi %1, %c160_i256 : i256 loc(#loc19) +// CHECK-NEXT: %35:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %34, %arg2 = %c3_i256) -> (i256, i256) { +// CHECK-NEXT: %60 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc19) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc19) +// CHECK-NEXT: %62 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %61, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %63 = arith.addi %arg1, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %64 = arith.addi %arg2, %c1_i256 : i256 loc(#loc19) +// CHECK-NEXT: scf.yield %63, %64 : i256, i256 loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %36 = arith.addi %1, %c224_i256 : i256 loc(#loc19) +// CHECK-NEXT: %37 = arith.subi %33, %3 : i256 loc(#loc19) +// CHECK-NEXT: %38 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %37, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %39 = llvm.inttoptr %c5_i256 : i256 to !llvm.ptr<5> loc(#loc19) +// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc19) +// CHECK-NEXT: %41 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %42 = arith.index_castui %40 : i256 to index loc(#loc19) +// CHECK-NEXT: %43 = arith.addi %33, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c5_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %46 = "llvm.intrcall"(%45, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc19) +// CHECK-NEXT: %47 = arith.muli %40, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %48 = arith.addi %43, %47 : i256 loc(#loc19) +// CHECK-NEXT: %49:2 = scf.for %arg0 = %c0 to %42 step %c1 iter_args(%arg1 = %43, %arg2 = %46) -> (i256, i256) { +// CHECK-NEXT: %60 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<5> loc(#loc19) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc19) +// CHECK-NEXT: %62 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %61, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %63 = arith.addi %arg1, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %64 = arith.addi %arg2, %c1_i256 : i256 loc(#loc19) +// CHECK-NEXT: scf.yield %63, %64 : i256, i256 loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %50 = arith.subi %48, %2 : i256 loc(#loc19) +// CHECK-NEXT: %51 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %50, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %52 = arith.subi %48, %1 : i256 loc(#loc19) +// CHECK-NEXT: %53 = arith.addi %52, %c31_i256 : i256 loc(#loc19) +// CHECK-NEXT: %54 = arith.andi %53, %c-32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %55 = arith.addi %1, %54 : i256 loc(#loc19) +// CHECK-NEXT: %56 = arith.cmpi ugt, %55, %c18446744073709551615_i256 : i256 loc(#loc19) +// CHECK-NEXT: %57 = arith.cmpi ult, %55, %1 : i256 loc(#loc19) +// CHECK-NEXT: %58 = arith.ori %56, %57 : i1 loc(#loc19) +// CHECK-NEXT: scf.if %58 { +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %61 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c65_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: "llvm.intrcall"(%62, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc19) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %59 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %55, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: return %1 : i256 loc(#loc20) +// CHECK-NEXT: } loc(#loc18) +// CHECK-NEXT: func.func @enc_struct_138(%arg0: i256 loc({{.*}}:63:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc22) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc22) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc22) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc23) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc24) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %5 = arith.addi %3, %c160_i256 : i256 loc(#loc24) +// CHECK-NEXT: %6:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %4, %arg3 = %1) -> (i256, i256) { +// CHECK-NEXT: %14 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc24) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc24) +// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<2> loc(#loc24) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc24) +// CHECK-NEXT: %21 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %22 = arith.addi %arg2, %c64_i256 : i256 loc(#loc24) +// CHECK-NEXT: %23 = arith.addi %arg3, %c64_i256 : i256 loc(#loc24) +// CHECK-NEXT: scf.yield %22, %23 : i256, i256 loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %7 = arith.subi %5, %4 : i256 loc(#loc24) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %9 = arith.addi %3, %c160_i256 : i256 loc(#loc24) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc24) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %3 : i256 loc(#loc24) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc24) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc24) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: return %3 : i256 loc(#loc25) +// CHECK-NEXT: } loc(#loc21) +// CHECK-NEXT: func.func @cd_nested_122(%arg0: i256 loc({{.*}}:59:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) +// CHECK-NEXT: %c320_i256 = arith.constant 320 : i256 loc(#loc) +// CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) +// CHECK-NEXT: %c384_i256 = arith.constant 384 : i256 loc(#loc) +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) +// CHECK-NEXT: %c352_i256 = arith.constant 352 : i256 loc(#loc) +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256 = arith.constant 46588223404076438002452388499589275425339095392816320687750512315683798253568 : i256 loc(#loc) +// CHECK-NEXT: %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256 = arith.constant 29517451765071250289932898678666425651196573092471976580941455186195129331566 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 = arith.constant 3618502788666131106986593281521497120414687020801267626233049500247285301247 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099523263123094306816 : i256 loc(#loc) // CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099014633433810337792 : i256 loc(#loc) // CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099231078946096545792 : i256 loc(#loc) // CHECK-NEXT: %c30_i256 = arith.constant 30 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) -// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c191_i256 = arith.constant 191 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc14) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc14) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc15) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc16) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc16) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %8 = arith.addi %3, %c160_i256 : i256 loc(#loc16) -// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc16) -// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %16 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc16) -// CHECK-NEXT: %17 = arith.subi %16, %1 : i256 loc(#loc16) -// CHECK-NEXT: %18 = arith.subi %17, %c31_i256 : i256 loc(#loc16) -// CHECK-NEXT: %19 = arith.cmpi sge, %15, %18 : i256 loc(#loc16) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc27) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc27) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc28) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc29) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc29) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %8 = arith.addi %3, %c160_i256 : i256 loc(#loc29) +// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc29) +// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %16 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc29) +// CHECK-NEXT: %17 = arith.subi %16, %1 : i256 loc(#loc29) +// CHECK-NEXT: %18 = arith.subi %17, %c191_i256 : i256 loc(#loc29) +// CHECK-NEXT: %19 = arith.cmpi sge, %15, %18 : i256 loc(#loc29) // CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %94, %c4_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c32_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %98 = arith.addi %94, %c36_i256 : i256 loc(#loc16) -// CHECK-NEXT: %99 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c30_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %100 = arith.addi %94, %c68_i256 : i256 loc(#loc16) -// CHECK-NEXT: %101 = llvm.inttoptr %100 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %101 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %102 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: "llvm.intrcall"(%102, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %20 = arith.addi %1, %15 : i256 loc(#loc16) -// CHECK-NEXT: %21 = arith.subi %8, %5 : i256 loc(#loc16) -// CHECK-NEXT: %22 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %23 = arith.addi %3, %c352_i256 : i256 loc(#loc16) -// CHECK-NEXT: %24 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %26 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %27 = arith.addi %3, %c192_i256 : i256 loc(#loc16) -// CHECK-NEXT: %28 = arith.addi %20, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %31 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %32 = arith.addi %3, %c224_i256 : i256 loc(#loc16) -// CHECK-NEXT: %33 = arith.addi %20, %c64_i256 : i256 loc(#loc16) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %36 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc16) -// CHECK-NEXT: %37 = arith.subi %36, %20 : i256 loc(#loc16) -// CHECK-NEXT: %38 = arith.subi %37, %c31_i256 : i256 loc(#loc16) -// CHECK-NEXT: %39 = arith.cmpi sge, %35, %38 : i256 loc(#loc16) +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c30_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%114, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %20 = arith.addi %1, %15 : i256 loc(#loc29) +// CHECK-NEXT: %21 = arith.subi %8, %5 : i256 loc(#loc29) +// CHECK-NEXT: %22 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %23 = arith.addi %3, %c352_i256 : i256 loc(#loc29) +// CHECK-NEXT: %24 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %26 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %27 = arith.addi %3, %c192_i256 : i256 loc(#loc29) +// CHECK-NEXT: %28 = arith.addi %20, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %31 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %32 = arith.addi %3, %c224_i256 : i256 loc(#loc29) +// CHECK-NEXT: %33 = arith.addi %20, %c64_i256 : i256 loc(#loc29) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %36 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc29) +// CHECK-NEXT: %37 = arith.subi %36, %20 : i256 loc(#loc29) +// CHECK-NEXT: %38 = arith.subi %37, %c31_i256 : i256 loc(#loc29) +// CHECK-NEXT: %39 = arith.cmpi sge, %35, %38 : i256 loc(#loc29) // CHECK-NEXT: scf.if %39 { -// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %94, %c4_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c32_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %98 = arith.addi %94, %c36_i256 : i256 loc(#loc16) -// CHECK-NEXT: %99 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c30_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %100 = arith.addi %94, %c68_i256 : i256 loc(#loc16) -// CHECK-NEXT: %101 = llvm.inttoptr %100 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %101 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %102 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: "llvm.intrcall"(%102, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %40 = arith.addi %20, %35 : i256 loc(#loc16) -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %43 = arith.addi %40, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %44 = arith.cmpi ugt, %42, %c18446744073709551615_i256 : i256 loc(#loc16) +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c30_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%114, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %40 = arith.addi %20, %35 : i256 loc(#loc29) +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %43 = arith.addi %40, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %44 = arith.cmpi ugt, %42, %c18446744073709551615_i256 : i256 loc(#loc29) // CHECK-NEXT: scf.if %44 { -// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %94, %c4_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c32_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %98 = arith.addi %94, %c36_i256 : i256 loc(#loc16) -// CHECK-NEXT: %99 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c30_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %100 = arith.addi %94, %c68_i256 : i256 loc(#loc16) -// CHECK-NEXT: %101 = llvm.inttoptr %100 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %101 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %102 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: "llvm.intrcall"(%102, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %45 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc16) -// CHECK-NEXT: %46 = arith.subi %45, %42 : i256 loc(#loc16) -// CHECK-NEXT: %47 = arith.cmpi sgt, %43, %46 : i256 loc(#loc16) +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c30_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%114, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %45 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc29) +// CHECK-NEXT: %46 = arith.subi %45, %42 : i256 loc(#loc29) +// CHECK-NEXT: %47 = arith.cmpi sgt, %43, %46 : i256 loc(#loc29) // CHECK-NEXT: scf.if %47 { -// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %94, %c4_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c32_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %98 = arith.addi %94, %c36_i256 : i256 loc(#loc16) -// CHECK-NEXT: %99 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c30_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %100 = arith.addi %94, %c68_i256 : i256 loc(#loc16) -// CHECK-NEXT: %101 = llvm.inttoptr %100 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %101 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %102 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: "llvm.intrcall"(%102, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %48 = arith.subi %23, %8 : i256 loc(#loc16) -// CHECK-NEXT: %49 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %48, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %50 = arith.addi %3, %c384_i256 : i256 loc(#loc16) -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %52 = llvm.inttoptr %43 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: "llvm.intr.memcpy"(%51, %52, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc16) -// CHECK-NEXT: %53 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %42, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %54 = arith.addi %42, %c31_i256 : i256 loc(#loc16) -// CHECK-NEXT: %55 = arith.andi %54, %c-32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %56 = arith.addi %50, %55 : i256 loc(#loc16) -// CHECK-NEXT: %57 = arith.addi %3, %c256_i256 : i256 loc(#loc16) -// CHECK-NEXT: %58 = arith.addi %20, %c96_i256 : i256 loc(#loc16) -// CHECK-NEXT: %59:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %57, %arg3 = %58) -> (i256, i256) { -// CHECK-NEXT: %93 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %94, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %arg2, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = arith.addi %arg3, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: scf.yield %96, %97 : i256, i256 loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %60 = arith.addi %3, %c320_i256 : i256 loc(#loc16) -// CHECK-NEXT: %61 = arith.addi %20, %c160_i256 : i256 loc(#loc16) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %63 = llvm.load %62 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %64 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc16) -// CHECK-NEXT: %65 = arith.subi %64, %20 : i256 loc(#loc16) -// CHECK-NEXT: %66 = arith.subi %65, %c31_i256 : i256 loc(#loc16) -// CHECK-NEXT: %67 = arith.cmpi sge, %63, %66 : i256 loc(#loc16) -// CHECK-NEXT: scf.if %67 { -// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %94, %c4_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c32_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %98 = arith.addi %94, %c36_i256 : i256 loc(#loc16) -// CHECK-NEXT: %99 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c30_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %100 = arith.addi %94, %c68_i256 : i256 loc(#loc16) -// CHECK-NEXT: %101 = llvm.inttoptr %100 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %101 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %102 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: "llvm.intrcall"(%102, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %68 = arith.addi %20, %63 : i256 loc(#loc16) -// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %70 = llvm.load %69 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %71 = arith.addi %68, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %72 = arith.cmpi ugt, %70, %c18446744073709551615_i256 : i256 loc(#loc16) -// CHECK-NEXT: scf.if %72 { -// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %94, %c4_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c32_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %98 = arith.addi %94, %c36_i256 : i256 loc(#loc16) -// CHECK-NEXT: %99 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c30_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %100 = arith.addi %94, %c68_i256 : i256 loc(#loc16) -// CHECK-NEXT: %101 = llvm.inttoptr %100 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %101 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %102 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: "llvm.intrcall"(%102, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %73 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc16) -// CHECK-NEXT: %74 = arith.muli %70, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %75 = arith.subi %73, %74 : i256 loc(#loc16) -// CHECK-NEXT: %76 = arith.cmpi sgt, %71, %75 : i256 loc(#loc16) -// CHECK-NEXT: scf.if %76 { -// CHECK-NEXT: %93 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %94, %c4_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = llvm.inttoptr %96 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c32_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %98 = arith.addi %94, %c36_i256 : i256 loc(#loc16) -// CHECK-NEXT: %99 = llvm.inttoptr %98 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c30_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %100 = arith.addi %94, %c68_i256 : i256 loc(#loc16) -// CHECK-NEXT: %101 = llvm.inttoptr %100 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %101 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %102 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: "llvm.intrcall"(%102, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc16) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %77 = arith.subi %56, %8 : i256 loc(#loc16) -// CHECK-NEXT: %78 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %77, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %79 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %70, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %80 = arith.index_castui %70 : i256 to index loc(#loc16) -// CHECK-NEXT: %81 = arith.addi %56, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %82 = arith.muli %70, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %83 = arith.addi %81, %82 : i256 loc(#loc16) -// CHECK-NEXT: %84:2 = scf.for %arg1 = %c0 to %80 step %c1 iter_args(%arg2 = %81, %arg3 = %71) -> (i256, i256) { -// CHECK-NEXT: %93 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %94 = llvm.load %93 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %95 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %94, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %96 = arith.addi %arg2, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %97 = arith.addi %arg3, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: scf.yield %96, %97 : i256, i256 loc(#loc16) -// CHECK-NEXT: } loc(#loc16) -// CHECK-NEXT: %85 = arith.addi %3, %c128_i256 : i256 loc(#loc16) -// CHECK-NEXT: %86 = arith.addi %1, %c64_i256 : i256 loc(#loc16) -// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<2> loc(#loc16) -// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc16) -// CHECK-NEXT: %89 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %88, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %90 = arith.subi %83, %4 : i256 loc(#loc16) -// CHECK-NEXT: %91 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %90, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %92 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %83, %92 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: return %3 : i256 loc(#loc17) -// CHECK-NEXT: } loc(#loc13) -// CHECK-NEXT: func.func @cd_big_97(%arg0: i256 loc({{.*}}:50:18)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c30_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%114, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %48 = arith.subi %23, %8 : i256 loc(#loc29) +// CHECK-NEXT: %49 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %48, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %50 = arith.addi %3, %c384_i256 : i256 loc(#loc29) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %52 = llvm.inttoptr %43 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: "llvm.intr.memcpy"(%51, %52, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc29) +// CHECK-NEXT: %53 = arith.addi %50, %42 : i256 loc(#loc29) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c0_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %55 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %42, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %56 = arith.addi %42, %c31_i256 : i256 loc(#loc29) +// CHECK-NEXT: %57 = arith.andi %56, %c-32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %58 = arith.addi %50, %57 : i256 loc(#loc29) +// CHECK-NEXT: %59 = arith.addi %3, %c256_i256 : i256 loc(#loc29) +// CHECK-NEXT: %60 = arith.addi %20, %c96_i256 : i256 loc(#loc29) +// CHECK-NEXT: %61 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %62 = llvm.inttoptr %60 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: "llvm.intr.memcpy"(%61, %62, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc29) +// CHECK-NEXT: %63 = arith.addi %3, %c320_i256 : i256 loc(#loc29) +// CHECK-NEXT: %64 = arith.addi %20, %c160_i256 : i256 loc(#loc29) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %67 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc29) +// CHECK-NEXT: %68 = arith.subi %67, %20 : i256 loc(#loc29) +// CHECK-NEXT: %69 = arith.subi %68, %c31_i256 : i256 loc(#loc29) +// CHECK-NEXT: %70 = arith.cmpi sge, %66, %69 : i256 loc(#loc29) +// CHECK-NEXT: scf.if %70 { +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c30_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%114, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %71 = arith.addi %20, %66 : i256 loc(#loc29) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %74 = arith.addi %71, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %75 = arith.cmpi ugt, %73, %c18446744073709551615_i256 : i256 loc(#loc29) +// CHECK-NEXT: scf.if %75 { +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c30_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%114, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %76 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc29) +// CHECK-NEXT: %77 = arith.muli %73, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %78 = arith.subi %76, %77 : i256 loc(#loc29) +// CHECK-NEXT: %79 = arith.cmpi sgt, %74, %78 : i256 loc(#loc29) +// CHECK-NEXT: scf.if %79 { +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c30_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%114, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %80 = arith.subi %58, %8 : i256 loc(#loc29) +// CHECK-NEXT: %81 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %80, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %82 = arith.cmpi ugt, %73, %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 : i256 loc(#loc29) +// CHECK-NEXT: scf.if %82 { +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %108 = arith.addi %106, %c4_i256 : i256 loc(#loc29) +// CHECK-NEXT: %109 = llvm.inttoptr %108 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c32_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %110 = arith.addi %106, %c36_i256 : i256 loc(#loc29) +// CHECK-NEXT: %111 = llvm.inttoptr %110 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c33_i256, %111 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %112 = arith.addi %106, %c68_i256 : i256 loc(#loc29) +// CHECK-NEXT: %113 = llvm.inttoptr %112 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256, %113 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %114 = arith.addi %106, %c100_i256 : i256 loc(#loc29) +// CHECK-NEXT: %115 = llvm.inttoptr %114 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256, %115 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %116 = llvm.inttoptr %106 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%116, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %83 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %73, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %84 = arith.addi %58, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %85 = arith.muli %73, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %86 = arith.addi %84, %85 : i256 loc(#loc29) +// CHECK-NEXT: %87 = arith.muli %73, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %88 = llvm.inttoptr %84 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %89 = llvm.inttoptr %74 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: "llvm.intr.memcpy"(%88, %89, %87) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc29) +// CHECK-NEXT: %90 = arith.addi %3, %c128_i256 : i256 loc(#loc29) +// CHECK-NEXT: %91 = arith.addi %1, %c64_i256 : i256 loc(#loc29) +// CHECK-NEXT: %92 = llvm.inttoptr %91 : i256 to !llvm.ptr<2> loc(#loc29) +// CHECK-NEXT: %93 = llvm.load %92 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc29) +// CHECK-NEXT: %94 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %93, %94 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %95 = arith.subi %86, %4 : i256 loc(#loc29) +// CHECK-NEXT: %96 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %95, %96 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %97 = arith.subi %86, %3 : i256 loc(#loc29) +// CHECK-NEXT: %98 = arith.addi %97, %c31_i256 : i256 loc(#loc29) +// CHECK-NEXT: %99 = arith.andi %98, %c-32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %100 = arith.addi %3, %99 : i256 loc(#loc29) +// CHECK-NEXT: %101 = arith.cmpi ugt, %100, %c18446744073709551615_i256 : i256 loc(#loc29) +// CHECK-NEXT: %102 = arith.cmpi ult, %100, %3 : i256 loc(#loc29) +// CHECK-NEXT: %103 = arith.ori %101, %102 : i1 loc(#loc29) +// CHECK-NEXT: scf.if %103 { +// CHECK-NEXT: %105 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %105 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %106 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c65_i256, %106 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %107 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%107, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) +// CHECK-NEXT: } loc(#loc29) +// CHECK-NEXT: %104 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %100, %104 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: return %3 : i256 loc(#loc30) +// CHECK-NEXT: } loc(#loc26) +// CHECK-NEXT: func.func @cd_big_108(%arg0: i256 loc({{.*}}:55:18)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c288_i256 = arith.constant 288 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) -// CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256 = arith.constant 46588223404076438002452388499589275425339095392816320687750512315683798253568 : i256 loc(#loc) +// CHECK-NEXT: %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256 = arith.constant 29517451765071250289932898678666425651196573092471976580941455186195129331566 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 = arith.constant 3618502788666131106986593281521497120414687020801267626233049500247285301247 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099523263123094306816 : i256 loc(#loc) // CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099014633433810337792 : i256 loc(#loc) // CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) @@ -1849,217 +2639,246 @@ contract C { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc19) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc19) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc20) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc21) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc21) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %8 = arith.addi %3, %c256_i256 : i256 loc(#loc21) -// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc21) -// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %16 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %17 = arith.addi %3, %c128_i256 : i256 loc(#loc21) -// CHECK-NEXT: %18 = arith.addi %1, %c64_i256 : i256 loc(#loc21) -// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %21 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc21) -// CHECK-NEXT: %22 = arith.subi %21, %1 : i256 loc(#loc21) -// CHECK-NEXT: %23 = arith.subi %22, %c31_i256 : i256 loc(#loc21) -// CHECK-NEXT: %24 = arith.cmpi sge, %20, %23 : i256 loc(#loc21) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc32) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc32) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc33) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc34) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc34) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %8 = arith.addi %3, %c256_i256 : i256 loc(#loc34) +// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc34) +// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc34) +// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc34) +// CHECK-NEXT: %16 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %17 = arith.addi %3, %c128_i256 : i256 loc(#loc34) +// CHECK-NEXT: %18 = arith.addi %1, %c64_i256 : i256 loc(#loc34) +// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc34) +// CHECK-NEXT: %21 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc34) +// CHECK-NEXT: %22 = arith.subi %21, %1 : i256 loc(#loc34) +// CHECK-NEXT: %23 = arith.subi %22, %c31_i256 : i256 loc(#loc34) +// CHECK-NEXT: %24 = arith.cmpi sge, %20, %23 : i256 loc(#loc34) // CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc21) -// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c30_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc21) -// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %82 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: "llvm.intrcall"(%82, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc21) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %25 = arith.addi %1, %20 : i256 loc(#loc21) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %28 = arith.addi %25, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %29 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc21) +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc34) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc34) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c30_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc34) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %94 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%94, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %25 = arith.addi %1, %20 : i256 loc(#loc34) +// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc34) +// CHECK-NEXT: %28 = arith.addi %25, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %29 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc34) // CHECK-NEXT: scf.if %29 { -// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc21) -// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c30_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc21) -// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %82 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: "llvm.intrcall"(%82, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc21) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %30 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc21) -// CHECK-NEXT: %31 = arith.subi %30, %27 : i256 loc(#loc21) -// CHECK-NEXT: %32 = arith.cmpi sgt, %28, %31 : i256 loc(#loc21) +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc34) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc34) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c30_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc34) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %94 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%94, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %30 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc34) +// CHECK-NEXT: %31 = arith.subi %30, %27 : i256 loc(#loc34) +// CHECK-NEXT: %32 = arith.cmpi sgt, %28, %31 : i256 loc(#loc34) // CHECK-NEXT: scf.if %32 { -// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc21) -// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c30_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc21) -// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %82 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: "llvm.intrcall"(%82, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc21) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %33 = arith.subi %8, %5 : i256 loc(#loc21) -// CHECK-NEXT: %34 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %35 = arith.addi %3, %c288_i256 : i256 loc(#loc21) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %37 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: "llvm.intr.memcpy"(%36, %37, %27) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc21) -// CHECK-NEXT: %38 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %27, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %39 = arith.addi %27, %c31_i256 : i256 loc(#loc21) -// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %41 = arith.addi %35, %40 : i256 loc(#loc21) -// CHECK-NEXT: %42 = arith.addi %3, %c160_i256 : i256 loc(#loc21) -// CHECK-NEXT: %43 = arith.addi %1, %c96_i256 : i256 loc(#loc21) -// CHECK-NEXT: %44:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %42, %arg3 = %43) -> (i256, i256) { -// CHECK-NEXT: %73 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %74, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %arg2, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = arith.addi %arg3, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: scf.yield %76, %77 : i256, i256 loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %45 = arith.addi %3, %c224_i256 : i256 loc(#loc21) -// CHECK-NEXT: %46 = arith.addi %1, %c160_i256 : i256 loc(#loc21) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %49 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc21) -// CHECK-NEXT: %50 = arith.subi %49, %1 : i256 loc(#loc21) -// CHECK-NEXT: %51 = arith.subi %50, %c31_i256 : i256 loc(#loc21) -// CHECK-NEXT: %52 = arith.cmpi sge, %48, %51 : i256 loc(#loc21) -// CHECK-NEXT: scf.if %52 { -// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc21) -// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c30_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc21) -// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %82 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: "llvm.intrcall"(%82, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc21) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %53 = arith.addi %1, %48 : i256 loc(#loc21) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %56 = arith.addi %53, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %57 = arith.cmpi ugt, %55, %c18446744073709551615_i256 : i256 loc(#loc21) -// CHECK-NEXT: scf.if %57 { -// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc21) -// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c30_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc21) -// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %82 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: "llvm.intrcall"(%82, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc21) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %58 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc21) -// CHECK-NEXT: %59 = arith.muli %55, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %60 = arith.subi %58, %59 : i256 loc(#loc21) -// CHECK-NEXT: %61 = arith.cmpi sgt, %56, %60 : i256 loc(#loc21) -// CHECK-NEXT: scf.if %61 { -// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 loc(#loc21) -// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c30_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 loc(#loc21) -// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %82 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: "llvm.intrcall"(%82, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc21) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %62 = arith.subi %41, %5 : i256 loc(#loc21) -// CHECK-NEXT: %63 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %62, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %64 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %55, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %65 = arith.index_castui %55 : i256 to index loc(#loc21) -// CHECK-NEXT: %66 = arith.addi %41, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %67 = arith.muli %55, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %68 = arith.addi %66, %67 : i256 loc(#loc21) -// CHECK-NEXT: %69:2 = scf.for %arg1 = %c0 to %65 step %c1 iter_args(%arg2 = %66, %arg3 = %56) -> (i256, i256) { -// CHECK-NEXT: %73 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc21) -// CHECK-NEXT: %75 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %74, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %76 = arith.addi %arg2, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: %77 = arith.addi %arg3, %c32_i256 : i256 loc(#loc21) -// CHECK-NEXT: scf.yield %76, %77 : i256, i256 loc(#loc21) -// CHECK-NEXT: } loc(#loc21) -// CHECK-NEXT: %70 = arith.subi %68, %4 : i256 loc(#loc21) -// CHECK-NEXT: %71 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %70, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %72 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %68, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: return %3 : i256 loc(#loc22) -// CHECK-NEXT: } loc(#loc18) -// CHECK-NEXT: func.func @mem_nested_83(%arg0: i256 loc({{.*}}:46:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc34) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc34) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c30_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc34) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %94 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%94, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %33 = arith.subi %8, %5 : i256 loc(#loc34) +// CHECK-NEXT: %34 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %35 = arith.addi %3, %c288_i256 : i256 loc(#loc34) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %37 = llvm.inttoptr %28 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: "llvm.intr.memcpy"(%36, %37, %27) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc34) +// CHECK-NEXT: %38 = arith.addi %35, %27 : i256 loc(#loc34) +// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c0_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %40 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %27, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %41 = arith.addi %27, %c31_i256 : i256 loc(#loc34) +// CHECK-NEXT: %42 = arith.andi %41, %c-32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %43 = arith.addi %35, %42 : i256 loc(#loc34) +// CHECK-NEXT: %44 = arith.addi %3, %c160_i256 : i256 loc(#loc34) +// CHECK-NEXT: %45 = arith.addi %1, %c96_i256 : i256 loc(#loc34) +// CHECK-NEXT: %46 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %47 = llvm.inttoptr %45 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: "llvm.intr.memcpy"(%46, %47, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc34) +// CHECK-NEXT: %48 = arith.addi %3, %c224_i256 : i256 loc(#loc34) +// CHECK-NEXT: %49 = arith.addi %1, %c160_i256 : i256 loc(#loc34) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: %51 = llvm.load %50 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc34) +// CHECK-NEXT: %52 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc34) +// CHECK-NEXT: %53 = arith.subi %52, %1 : i256 loc(#loc34) +// CHECK-NEXT: %54 = arith.subi %53, %c31_i256 : i256 loc(#loc34) +// CHECK-NEXT: %55 = arith.cmpi sge, %51, %54 : i256 loc(#loc34) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc34) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc34) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c30_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc34) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %94 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%94, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %56 = arith.addi %1, %51 : i256 loc(#loc34) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: %58 = llvm.load %57 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc34) +// CHECK-NEXT: %59 = arith.addi %56, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %60 = arith.cmpi ugt, %58, %c18446744073709551615_i256 : i256 loc(#loc34) +// CHECK-NEXT: scf.if %60 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc34) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc34) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c30_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc34) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %94 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%94, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %61 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc34) +// CHECK-NEXT: %62 = arith.muli %58, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %63 = arith.subi %61, %62 : i256 loc(#loc34) +// CHECK-NEXT: %64 = arith.cmpi sgt, %59, %63 : i256 loc(#loc34) +// CHECK-NEXT: scf.if %64 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc34) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc34) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c30_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc34) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %94 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%94, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %65 = arith.subi %43, %5 : i256 loc(#loc34) +// CHECK-NEXT: %66 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %65, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %67 = arith.cmpi ugt, %58, %c3618502788666131106986593281521497120414687020801267626233049500247285301247_i256 : i256 loc(#loc34) +// CHECK-NEXT: scf.if %67 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc34) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc34) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c33_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc34) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c29517451765071250289932898678666425651196573092471976580941455186195129331566_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc34) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c46588223404076438002452388499589275425339095392816320687750512315683798253568_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %68 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %58, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %69 = arith.addi %43, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %70 = arith.muli %58, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %71 = arith.addi %69, %70 : i256 loc(#loc34) +// CHECK-NEXT: %72 = arith.muli %58, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %73 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %74 = llvm.inttoptr %59 : i256 to !llvm.ptr<2> loc(#loc34) +// CHECK-NEXT: "llvm.intr.memcpy"(%73, %74, %72) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc34) +// CHECK-NEXT: %75 = arith.subi %71, %4 : i256 loc(#loc34) +// CHECK-NEXT: %76 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %75, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %77 = arith.subi %71, %3 : i256 loc(#loc34) +// CHECK-NEXT: %78 = arith.addi %77, %c31_i256 : i256 loc(#loc34) +// CHECK-NEXT: %79 = arith.andi %78, %c-32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %80 = arith.addi %3, %79 : i256 loc(#loc34) +// CHECK-NEXT: %81 = arith.cmpi ugt, %80, %c18446744073709551615_i256 : i256 loc(#loc34) +// CHECK-NEXT: %82 = arith.cmpi ult, %80, %3 : i256 loc(#loc34) +// CHECK-NEXT: %83 = arith.ori %81, %82 : i1 loc(#loc34) +// CHECK-NEXT: scf.if %83 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %84 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %80, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: return %3 : i256 loc(#loc35) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: func.func @mem_nested_94(%arg0: i256 loc({{.*}}:51:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c320_i256 = arith.constant 320 : i256 loc(#loc) // CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) @@ -2069,246 +2888,308 @@ contract C { // CHECK-NEXT: %c352_i256 = arith.constant 352 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc24) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc24) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc24) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc25) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc26) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc26) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %8 = arith.addi %3, %c160_i256 : i256 loc(#loc26) -// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc26) -// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %16 = arith.subi %8, %5 : i256 loc(#loc26) -// CHECK-NEXT: %17 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %18 = arith.addi %3, %c352_i256 : i256 loc(#loc26) -// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %21 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %22 = arith.addi %3, %c192_i256 : i256 loc(#loc26) -// CHECK-NEXT: %23 = arith.addi %15, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %26 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %27 = arith.addi %3, %c224_i256 : i256 loc(#loc26) -// CHECK-NEXT: %28 = arith.addi %15, %c64_i256 : i256 loc(#loc26) -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %31 = arith.subi %18, %8 : i256 loc(#loc26) -// CHECK-NEXT: %32 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %33 = arith.addi %3, %c384_i256 : i256 loc(#loc26) -// CHECK-NEXT: %34 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %36 = arith.addi %30, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %37 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %38 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: "llvm.intr.memmove"(%37, %38, %35) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc26) -// CHECK-NEXT: %39 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %35, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %40 = arith.addi %35, %c31_i256 : i256 loc(#loc26) -// CHECK-NEXT: %41 = arith.andi %40, %c-32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %42 = arith.addi %33, %41 : i256 loc(#loc26) -// CHECK-NEXT: %43 = arith.addi %3, %c256_i256 : i256 loc(#loc26) -// CHECK-NEXT: %44 = arith.addi %15, %c96_i256 : i256 loc(#loc26) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %47:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %43, %arg3 = %46) -> (i256, i256) { -// CHECK-NEXT: %71 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %73 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %72, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %74 = arith.addi %arg2, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %75 = arith.addi %arg3, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: scf.yield %74, %75 : i256, i256 loc(#loc26) -// CHECK-NEXT: } loc(#loc26) -// CHECK-NEXT: %48 = arith.addi %3, %c320_i256 : i256 loc(#loc26) -// CHECK-NEXT: %49 = arith.addi %15, %c128_i256 : i256 loc(#loc26) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %51 = llvm.load %50 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %52 = arith.subi %42, %8 : i256 loc(#loc26) -// CHECK-NEXT: %53 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %52, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %54 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %56 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %55, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %57 = arith.index_castui %55 : i256 to index loc(#loc26) -// CHECK-NEXT: %58 = arith.addi %42, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %59 = arith.addi %51, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %60 = arith.muli %55, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %61 = arith.addi %58, %60 : i256 loc(#loc26) -// CHECK-NEXT: %62:2 = scf.for %arg1 = %c0 to %57 step %c1 iter_args(%arg2 = %58, %arg3 = %59) -> (i256, i256) { -// CHECK-NEXT: %71 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %73 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %72, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %74 = arith.addi %arg2, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %75 = arith.addi %arg3, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: scf.yield %74, %75 : i256, i256 loc(#loc26) -// CHECK-NEXT: } loc(#loc26) -// CHECK-NEXT: %63 = arith.addi %3, %c128_i256 : i256 loc(#loc26) -// CHECK-NEXT: %64 = arith.addi %1, %c64_i256 : i256 loc(#loc26) -// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %67 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %66, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %68 = arith.subi %61, %4 : i256 loc(#loc26) -// CHECK-NEXT: %69 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %68, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %70 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %61, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: return %3 : i256 loc(#loc27) -// CHECK-NEXT: } loc(#loc23) -// CHECK-NEXT: func.func @mem_big_69(%arg0: i256 loc({{.*}}:42:19)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc37) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc37) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc37) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc38) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc39) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %8 = arith.addi %3, %c160_i256 : i256 loc(#loc39) +// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc39) +// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %16 = arith.subi %8, %5 : i256 loc(#loc39) +// CHECK-NEXT: %17 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %18 = arith.addi %3, %c352_i256 : i256 loc(#loc39) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %21 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %22 = arith.addi %3, %c192_i256 : i256 loc(#loc39) +// CHECK-NEXT: %23 = arith.addi %15, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %26 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %27 = arith.addi %3, %c224_i256 : i256 loc(#loc39) +// CHECK-NEXT: %28 = arith.addi %15, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %31 = arith.subi %18, %8 : i256 loc(#loc39) +// CHECK-NEXT: %32 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %33 = arith.addi %3, %c384_i256 : i256 loc(#loc39) +// CHECK-NEXT: %34 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %36 = arith.addi %30, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %37 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %38 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: "llvm.intr.memmove"(%37, %38, %35) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc39) +// CHECK-NEXT: %39 = arith.addi %33, %35 : i256 loc(#loc39) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %41 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %35, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %42 = arith.addi %35, %c31_i256 : i256 loc(#loc39) +// CHECK-NEXT: %43 = arith.andi %42, %c-32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %44 = arith.addi %33, %43 : i256 loc(#loc39) +// CHECK-NEXT: %45 = arith.addi %3, %c256_i256 : i256 loc(#loc39) +// CHECK-NEXT: %46 = arith.addi %15, %c96_i256 : i256 loc(#loc39) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %49:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %45, %arg3 = %48) -> (i256, i256) { +// CHECK-NEXT: %80 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %81 = llvm.load %80 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %82 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %81, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %83 = arith.addi %arg2, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %84 = arith.addi %arg3, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: scf.yield %83, %84 : i256, i256 loc(#loc39) +// CHECK-NEXT: } loc(#loc39) +// CHECK-NEXT: %50 = arith.addi %3, %c320_i256 : i256 loc(#loc39) +// CHECK-NEXT: %51 = arith.addi %15, %c128_i256 : i256 loc(#loc39) +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %54 = arith.subi %44, %8 : i256 loc(#loc39) +// CHECK-NEXT: %55 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %54, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %56 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %58 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %59 = arith.index_castui %57 : i256 to index loc(#loc39) +// CHECK-NEXT: %60 = arith.addi %44, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %61 = arith.addi %53, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %62 = arith.muli %57, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %63 = arith.addi %60, %62 : i256 loc(#loc39) +// CHECK-NEXT: %64:2 = scf.for %arg1 = %c0 to %59 step %c1 iter_args(%arg2 = %60, %arg3 = %61) -> (i256, i256) { +// CHECK-NEXT: %80 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %81 = llvm.load %80 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %82 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %81, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %83 = arith.addi %arg2, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %84 = arith.addi %arg3, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: scf.yield %83, %84 : i256, i256 loc(#loc39) +// CHECK-NEXT: } loc(#loc39) +// CHECK-NEXT: %65 = arith.addi %3, %c128_i256 : i256 loc(#loc39) +// CHECK-NEXT: %66 = arith.addi %1, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %69 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %68, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %70 = arith.subi %63, %4 : i256 loc(#loc39) +// CHECK-NEXT: %71 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %70, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %72 = arith.subi %63, %3 : i256 loc(#loc39) +// CHECK-NEXT: %73 = arith.addi %72, %c31_i256 : i256 loc(#loc39) +// CHECK-NEXT: %74 = arith.andi %73, %c-32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %75 = arith.addi %3, %74 : i256 loc(#loc39) +// CHECK-NEXT: %76 = arith.cmpi ugt, %75, %c18446744073709551615_i256 : i256 loc(#loc39) +// CHECK-NEXT: %77 = arith.cmpi ult, %75, %3 : i256 loc(#loc39) +// CHECK-NEXT: %78 = arith.ori %76, %77 : i1 loc(#loc39) +// CHECK-NEXT: scf.if %78 { +// CHECK-NEXT: %80 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %81 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c65_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %82 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: "llvm.intrcall"(%82, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) +// CHECK-NEXT: } loc(#loc39) +// CHECK-NEXT: %79 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %75, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: return %3 : i256 loc(#loc40) +// CHECK-NEXT: } loc(#loc36) +// CHECK-NEXT: func.func @mem_big_80(%arg0: i256 loc({{.*}}:47:19)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c288_i256 = arith.constant 288 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc29) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc29) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc29) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc30) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc31) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc31) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %8 = arith.addi %3, %c256_i256 : i256 loc(#loc31) -// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc31) -// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %16 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %17 = arith.addi %3, %c128_i256 : i256 loc(#loc31) -// CHECK-NEXT: %18 = arith.addi %1, %c64_i256 : i256 loc(#loc31) -// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %21 = arith.subi %8, %5 : i256 loc(#loc31) -// CHECK-NEXT: %22 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %23 = arith.addi %3, %c288_i256 : i256 loc(#loc31) -// CHECK-NEXT: %24 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %26 = arith.addi %20, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %27 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %28 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: "llvm.intr.memmove"(%27, %28, %25) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc31) -// CHECK-NEXT: %29 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %30 = arith.addi %25, %c31_i256 : i256 loc(#loc31) -// CHECK-NEXT: %31 = arith.andi %30, %c-32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %32 = arith.addi %23, %31 : i256 loc(#loc31) -// CHECK-NEXT: %33 = arith.addi %3, %c160_i256 : i256 loc(#loc31) -// CHECK-NEXT: %34 = arith.addi %1, %c96_i256 : i256 loc(#loc31) -// CHECK-NEXT: %35 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %37:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %33, %arg3 = %36) -> (i256, i256) { -// CHECK-NEXT: %56 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %58 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %59 = arith.addi %arg2, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %60 = arith.addi %arg3, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: scf.yield %59, %60 : i256, i256 loc(#loc31) -// CHECK-NEXT: } loc(#loc31) -// CHECK-NEXT: %38 = arith.addi %3, %c224_i256 : i256 loc(#loc31) -// CHECK-NEXT: %39 = arith.addi %1, %c128_i256 : i256 loc(#loc31) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %42 = arith.subi %32, %5 : i256 loc(#loc31) -// CHECK-NEXT: %43 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %42, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %44 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %46 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %45, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %47 = arith.index_castui %45 : i256 to index loc(#loc31) -// CHECK-NEXT: %48 = arith.addi %32, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %49 = arith.addi %41, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %50 = arith.muli %45, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %51 = arith.addi %48, %50 : i256 loc(#loc31) -// CHECK-NEXT: %52:2 = scf.for %arg1 = %c0 to %47 step %c1 iter_args(%arg2 = %48, %arg3 = %49) -> (i256, i256) { -// CHECK-NEXT: %56 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %58 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %59 = arith.addi %arg2, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: %60 = arith.addi %arg3, %c32_i256 : i256 loc(#loc31) -// CHECK-NEXT: scf.yield %59, %60 : i256, i256 loc(#loc31) -// CHECK-NEXT: } loc(#loc31) -// CHECK-NEXT: %53 = arith.subi %51, %4 : i256 loc(#loc31) -// CHECK-NEXT: %54 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %53, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %51, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: return %3 : i256 loc(#loc32) -// CHECK-NEXT: } loc(#loc28) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc42) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc42) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc42) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc43) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc44) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc44) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %8 = arith.addi %3, %c256_i256 : i256 loc(#loc44) +// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %11 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %12 = arith.addi %3, %c96_i256 : i256 loc(#loc44) +// CHECK-NEXT: %13 = arith.addi %1, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %16 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %17 = arith.addi %3, %c128_i256 : i256 loc(#loc44) +// CHECK-NEXT: %18 = arith.addi %1, %c64_i256 : i256 loc(#loc44) +// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %21 = arith.subi %8, %5 : i256 loc(#loc44) +// CHECK-NEXT: %22 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %23 = arith.addi %3, %c288_i256 : i256 loc(#loc44) +// CHECK-NEXT: %24 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %26 = arith.addi %20, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %27 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %28 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: "llvm.intr.memmove"(%27, %28, %25) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc44) +// CHECK-NEXT: %29 = arith.addi %23, %25 : i256 loc(#loc44) +// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %c0_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %31 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %25, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %32 = arith.addi %25, %c31_i256 : i256 loc(#loc44) +// CHECK-NEXT: %33 = arith.andi %32, %c-32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %34 = arith.addi %23, %33 : i256 loc(#loc44) +// CHECK-NEXT: %35 = arith.addi %3, %c160_i256 : i256 loc(#loc44) +// CHECK-NEXT: %36 = arith.addi %1, %c96_i256 : i256 loc(#loc44) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %39:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %35, %arg3 = %38) -> (i256, i256) { +// CHECK-NEXT: %65 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %67 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %66, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %68 = arith.addi %arg2, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %69 = arith.addi %arg3, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: scf.yield %68, %69 : i256, i256 loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: %40 = arith.addi %3, %c224_i256 : i256 loc(#loc44) +// CHECK-NEXT: %41 = arith.addi %1, %c128_i256 : i256 loc(#loc44) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %44 = arith.subi %34, %5 : i256 loc(#loc44) +// CHECK-NEXT: %45 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %44, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %46 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %48 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %47, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %49 = arith.index_castui %47 : i256 to index loc(#loc44) +// CHECK-NEXT: %50 = arith.addi %34, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %51 = arith.addi %43, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %52 = arith.muli %47, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %53 = arith.addi %50, %52 : i256 loc(#loc44) +// CHECK-NEXT: %54:2 = scf.for %arg1 = %c0 to %49 step %c1 iter_args(%arg2 = %50, %arg3 = %51) -> (i256, i256) { +// CHECK-NEXT: %65 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %67 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %66, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %68 = arith.addi %arg2, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %69 = arith.addi %arg3, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: scf.yield %68, %69 : i256, i256 loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: %55 = arith.subi %53, %4 : i256 loc(#loc44) +// CHECK-NEXT: %56 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %55, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %57 = arith.subi %53, %3 : i256 loc(#loc44) +// CHECK-NEXT: %58 = arith.addi %57, %c31_i256 : i256 loc(#loc44) +// CHECK-NEXT: %59 = arith.andi %58, %c-32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %60 = arith.addi %3, %59 : i256 loc(#loc44) +// CHECK-NEXT: %61 = arith.cmpi ugt, %60, %c18446744073709551615_i256 : i256 loc(#loc44) +// CHECK-NEXT: %62 = arith.cmpi ult, %60, %3 : i256 loc(#loc44) +// CHECK-NEXT: %63 = arith.ori %61, %62 : i1 loc(#loc44) +// CHECK-NEXT: scf.if %63 { +// CHECK-NEXT: %65 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %66 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %c65_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %67 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: "llvm.intrcall"(%67, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc44) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %60, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: return %3 : i256 loc(#loc45) +// CHECK-NEXT: } loc(#loc41) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: #loc = loc(unknown) // CHECK-NEXT: #loc1 = loc({{.*}}:2:0) -// CHECK-NEXT: #loc2 = loc({{.*}}:66:2) -// CHECK-NEXT: #loc3 = loc({{.*}}:40:2) -// CHECK-NEXT: #loc4 = loc({{.*}}:67:11) -// CHECK-NEXT: #loc5 = loc({{.*}}:67:4) -// CHECK-NEXT: #loc6 = loc({{.*}}:62:2) -// CHECK-NEXT: #loc7 = loc({{.*}}:39:2) -// CHECK-NEXT: #loc8 = loc({{.*}}:63:11) -// CHECK-NEXT: #loc9 = loc({{.*}}:63:4) -// CHECK-NEXT: #loc10 = loc({{.*}}:58:2) -// CHECK-NEXT: #loc11 = loc({{.*}}:59:11) -// CHECK-NEXT: #loc12 = loc({{.*}}:59:4) -// CHECK-NEXT: #loc13 = loc({{.*}}:54:2) -// CHECK-NEXT: #loc15 = loc({{.*}}:55:22) -// CHECK-NEXT: #loc16 = loc({{.*}}:55:11) -// CHECK-NEXT: #loc17 = loc({{.*}}:55:4) -// CHECK-NEXT: #loc18 = loc({{.*}}:50:2) -// CHECK-NEXT: #loc20 = loc({{.*}}:51:22) -// CHECK-NEXT: #loc21 = loc({{.*}}:51:11) -// CHECK-NEXT: #loc22 = loc({{.*}}:51:4) -// CHECK-NEXT: #loc23 = loc({{.*}}:46:2) -// CHECK-NEXT: #loc25 = loc({{.*}}:47:22) -// CHECK-NEXT: #loc26 = loc({{.*}}:47:11) -// CHECK-NEXT: #loc27 = loc({{.*}}:47:4) -// CHECK-NEXT: #loc28 = loc({{.*}}:42:2) -// CHECK-NEXT: #loc30 = loc({{.*}}:43:22) -// CHECK-NEXT: #loc31 = loc({{.*}}:43:11) -// CHECK-NEXT: #loc32 = loc({{.*}}:43:4) +// CHECK-NEXT: #loc2 = loc({{.*}}:83:2) +// CHECK-NEXT: #loc3 = loc({{.*}}:45:2) +// CHECK-NEXT: #loc4 = loc({{.*}}:84:11) +// CHECK-NEXT: #loc5 = loc({{.*}}:84:4) +// CHECK-NEXT: #loc6 = loc({{.*}}:79:2) +// CHECK-NEXT: #loc7 = loc({{.*}}:44:2) +// CHECK-NEXT: #loc8 = loc({{.*}}:80:11) +// CHECK-NEXT: #loc9 = loc({{.*}}:80:4) +// CHECK-NEXT: #loc10 = loc({{.*}}:75:2) +// CHECK-NEXT: #loc11 = loc({{.*}}:43:2) +// CHECK-NEXT: #loc12 = loc({{.*}}:76:11) +// CHECK-NEXT: #loc13 = loc({{.*}}:76:4) +// CHECK-NEXT: #loc14 = loc({{.*}}:71:2) +// CHECK-NEXT: #loc15 = loc({{.*}}:42:2) +// CHECK-NEXT: #loc16 = loc({{.*}}:72:11) +// CHECK-NEXT: #loc17 = loc({{.*}}:72:4) +// CHECK-NEXT: #loc18 = loc({{.*}}:67:2) +// CHECK-NEXT: #loc19 = loc({{.*}}:68:11) +// CHECK-NEXT: #loc20 = loc({{.*}}:68:4) +// CHECK-NEXT: #loc21 = loc({{.*}}:63:2) +// CHECK-NEXT: #loc23 = loc({{.*}}:64:22) +// CHECK-NEXT: #loc24 = loc({{.*}}:64:11) +// CHECK-NEXT: #loc25 = loc({{.*}}:64:4) +// CHECK-NEXT: #loc26 = loc({{.*}}:59:2) +// CHECK-NEXT: #loc28 = loc({{.*}}:60:22) +// CHECK-NEXT: #loc29 = loc({{.*}}:60:11) +// CHECK-NEXT: #loc30 = loc({{.*}}:60:4) +// CHECK-NEXT: #loc31 = loc({{.*}}:55:2) +// CHECK-NEXT: #loc33 = loc({{.*}}:56:22) +// CHECK-NEXT: #loc34 = loc({{.*}}:56:11) +// CHECK-NEXT: #loc35 = loc({{.*}}:56:4) +// CHECK-NEXT: #loc36 = loc({{.*}}:51:2) +// CHECK-NEXT: #loc38 = loc({{.*}}:52:22) +// CHECK-NEXT: #loc39 = loc({{.*}}:52:11) +// CHECK-NEXT: #loc40 = loc({{.*}}:52:4) +// CHECK-NEXT: #loc41 = loc({{.*}}:47:2) +// CHECK-NEXT: #loc43 = loc({{.*}}:48:22) +// CHECK-NEXT: #loc44 = loc({{.*}}:48:11) +// CHECK-NEXT: #loc45 = loc({{.*}}:48:4) // CHECK-EMPTY: diff --git a/test/lit/mlirCodegen/EVM/address-cast.sol b/test/lit/mlirCodegen/EVM/address-cast.sol index fbe288dac..6935af1e2 100644 --- a/test/lit/mlirCodegen/EVM/address-cast.sol +++ b/test/lit/mlirCodegen/EVM/address-cast.sol @@ -54,6 +54,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -62,8 +69,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_121"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -71,22 +78,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_121() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_121_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_121_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_121_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_121_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/array-copy.sol b/test/lit/mlirCodegen/EVM/array-copy.sol index be2e314ba..a39da2394 100644 --- a/test/lit/mlirCodegen/EVM/array-copy.sol +++ b/test/lit/mlirCodegen/EVM/array-copy.sol @@ -34,6 +34,13 @@ contract ArrayCopy { // CHECK-NEXT: llvm.unreachable // CHECK-NEXT: } // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 @@ -42,8 +49,8 @@ contract ArrayCopy { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["ArrayCopy_196"], name = "evm.datasize"}> : () -> i256 @@ -51,22 +58,36 @@ contract ArrayCopy { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () // CHECK-NEXT: call @ArrayCopy_196() : () -> () -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["ArrayCopy_196_deployed"], name = "evm.dataoffset"}> : () -> i256 -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["ArrayCopy_196_deployed"], name = "evm.datasize"}> : () -> i256 -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["ArrayCopy_196_deployed"], name = "evm.dataoffset"}> : () -> i256 +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["ArrayCopy_196_deployed"], name = "evm.datasize"}> : () -> i256 +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: call @".unreachable"() : () -> () // CHECK-NEXT: llvm.unreachable // CHECK-NEXT: } @@ -79,34 +100,36 @@ contract ArrayCopy { // CHECK-NEXT: } // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c196_i256 = arith.constant 196 : i256 +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 // CHECK-NEXT: %c2 = arith.constant 2 : index // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 // CHECK-NEXT: %0 = llvm.mlir.undef : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c51765758038840874448248112245855622722229435958027532839407121884968680161280_i256 = arith.constant 51765758038840874448248112245855622722229435958027532839407121884968680161280 : i256 // CHECK-NEXT: %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256 = arith.constant 45888551966424197807937402689295079693071411769653575580334356259971920822272 : i256 // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256 = arith.constant 29517451764962235613010368778373659638394623262010481748738546747006033225331 : i256 // CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 -// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 // CHECK-NEXT: %c3 = arith.constant 3 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 @@ -127,80 +150,92 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c96_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = arith.cmpi sle, %2, %c35_i256 : i256 // CHECK-NEXT: scf.if %13 { -// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 -// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %29 = arith.addi %27, %c4_i256 : i256 +// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %31 = arith.addi %27, %c36_i256 : i256 +// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %33 = arith.addi %27, %c68_i256 : i256 +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %35 = arith.addi %27, %c100_i256 : i256 +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%37, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> // CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %16 = arith.addi %15, %c96_i256 : i256 -// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %18 = arith.cmpi ult, %2, %c100_i256 : i256 -// CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 -// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %15 : i256 +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %21 = arith.cmpi ult, %2, %c100_i256 : i256 +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %29 = arith.addi %27, %c4_i256 : i256 +// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %31 = arith.addi %27, %c36_i256 : i256 +// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %33 = arith.addi %27, %c68_i256 : i256 +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %35 = arith.addi %27, %c100_i256 : i256 +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%37, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %19:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %15, %arg2 = %c4_i256) -> (i256, i256) { -// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %25 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %26 = arith.addi %arg1, %c32_i256 : i256 -// CHECK-NEXT: %27 = arith.addi %arg2, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %26, %27 : i256, i256 +// CHECK-NEXT: %22:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %15, %arg2 = %c4_i256) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %28 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %29 = arith.addi %arg1, %c32_i256 : i256 +// CHECK-NEXT: %30 = arith.addi %arg2, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %29, %30 : i256, i256 // CHECK-NEXT: } // CHECK-NEXT: func.call @m2s_stat_31(%15) : (i256) -> () -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%22, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%25, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -208,63 +243,63 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%39, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%39, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %40, %c4_i256 : i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %40, %c36_i256 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c34_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %40, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %40, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%50, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c34_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 // CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 // CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %40, %c4_i256 : i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %40, %c36_i256 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %40, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %40, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%50, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> @@ -274,61 +309,74 @@ contract ArrayCopy { // CHECK-NEXT: %23 = arith.addi %21, %22 : i256 // CHECK-NEXT: %24 = arith.cmpi ugt, %23, %2 : i256 // CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %40, %c4_i256 : i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %40, %c36_i256 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %40, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %40, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%50, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %25 = arith.muli %20, %c32_i256 : i256 // CHECK-NEXT: %26 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %26 { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c65_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%41, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %27 = arith.addi %25, %c32_i256 : i256 -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %30 = arith.addi %29, %27 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %20, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %33 = arith.addi %29, %c32_i256 : i256 -// CHECK-NEXT: %34 = arith.index_castui %20 : i256 to index -// CHECK-NEXT: %35:2 = scf.for %arg0 = %c0 to %34 step %c1 iter_args(%arg1 = %33, %arg2 = %21) -> (i256, i256) { -// CHECK-NEXT: %39 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %arg1, %c32_i256 : i256 -// CHECK-NEXT: %43 = arith.addi %arg2, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %42, %43 : i256, i256 -// CHECK-NEXT: } -// CHECK-NEXT: func.call @m2s_dyn_42(%29) : (i256) -> () -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%38, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %29 = arith.addi %25, %c63_i256 : i256 +// CHECK-NEXT: %30 = arith.andi %29, %c-32_i256 : i256 +// CHECK-NEXT: %31 = arith.addi %28, %30 : i256 +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %28 : i256 +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %36 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %20, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = arith.addi %28, %c32_i256 : i256 +// CHECK-NEXT: %38 = arith.index_castui %20 : i256 to index +// CHECK-NEXT: %39:2 = scf.for %arg0 = %c0 to %38 step %c1 iter_args(%arg1 = %37, %arg2 = %21) -> (i256, i256) { +// CHECK-NEXT: %43 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %45 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %44, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %arg1, %c32_i256 : i256 +// CHECK-NEXT: %47 = arith.addi %arg2, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %46, %47 : i256, i256 +// CHECK-NEXT: } +// CHECK-NEXT: func.call @m2s_dyn_42(%28) : (i256) -> () +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -399,31 +447,53 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%18, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c96_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%18, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %13 = func.call @cd2m_stat_75(%c4_i256) : (i256) -> i256 -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %16:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %15, %arg2 = %13) -> (i256, i256) { -// CHECK-NEXT: %18 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %20 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %21 = arith.addi %arg1, %c32_i256 : i256 -// CHECK-NEXT: %22 = arith.addi %arg2, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %21, %22 : i256, i256 -// CHECK-NEXT: } -// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%17, %c96_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %13 = arith.cmpi ult, %2, %c100_i256 : i256 +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %22 = arith.addi %20, %c4_i256 : i256 +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %24 = arith.addi %20, %c36_i256 : i256 +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %26 = arith.addi %20, %c68_i256 : i256 +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %28 = arith.addi %20, %c100_i256 : i256 +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %30 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%30, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %14 = func.call @cd2m_stat_75(%c4_i256) : (i256) -> i256 +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %17:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %16, %arg2 = %14) -> (i256, i256) { +// CHECK-NEXT: %19 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %21 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %22 = arith.addi %arg1, %c32_i256 : i256 +// CHECK-NEXT: %23 = arith.addi %arg2, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %22, %23 : i256, i256 +// CHECK-NEXT: } +// CHECK-NEXT: %18 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%18, %c96_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -431,121 +501,143 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%44, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%44, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 -// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c34_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c34_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 // CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 // CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 -// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> // CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %21 = arith.addi %14, %c36_i256 : i256 -// CHECK-NEXT: %22 = arith.muli %20, %c32_i256 : i256 -// CHECK-NEXT: %23 = arith.addi %21, %22 : i256 -// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %2 : i256 -// CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 -// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %22 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038840874448248112245855622722229435958027532839407121884968680161280_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %25 = llvm.insertvalue %21, %0[0] : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %26 = llvm.insertvalue %20, %25[1] : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %27 = func.call @cd2m_dyn_87(%26) : (!llvm.struct<(i256, i256)>) -> i256 -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %30 = arith.addi %29, %c32_i256 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %34 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %35 = arith.index_castui %33 : i256 to index -// CHECK-NEXT: %36 = arith.addi %29, %c64_i256 : i256 -// CHECK-NEXT: %37 = arith.addi %27, %c32_i256 : i256 -// CHECK-NEXT: %38 = arith.muli %33, %c32_i256 : i256 -// CHECK-NEXT: %39 = arith.addi %36, %38 : i256 -// CHECK-NEXT: %40:2 = scf.for %arg0 = %c0 to %35 step %c1 iter_args(%arg1 = %36, %arg2 = %37) -> (i256, i256) { -// CHECK-NEXT: %43 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %44, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %arg1, %c32_i256 : i256 -// CHECK-NEXT: %47 = arith.addi %arg2, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %46, %47 : i256, i256 +// CHECK-NEXT: %23 = arith.muli %20, %c32_i256 : i256 +// CHECK-NEXT: %24 = arith.addi %21, %23 : i256 +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %2 : i256 +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %26 = llvm.insertvalue %21, %0[0] : !llvm.struct<(i256, i256)> +// CHECK-NEXT: %27 = llvm.insertvalue %20, %26[1] : !llvm.struct<(i256, i256)> +// CHECK-NEXT: %28 = func.call @cd2m_dyn_87(%27) : (!llvm.struct<(i256, i256)>) -> i256 +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %31 = arith.addi %30, %c32_i256 : i256 +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %33 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %35 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %36 = arith.index_castui %34 : i256 to index +// CHECK-NEXT: %37 = arith.addi %30, %c64_i256 : i256 +// CHECK-NEXT: %38 = arith.addi %28, %c32_i256 : i256 +// CHECK-NEXT: %39 = arith.muli %34, %c32_i256 : i256 +// CHECK-NEXT: %40 = arith.addi %37, %39 : i256 +// CHECK-NEXT: %41:2 = scf.for %arg0 = %c0 to %36 step %c1 iter_args(%arg1 = %37, %arg2 = %38) -> (i256, i256) { +// CHECK-NEXT: %44 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %45, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %arg1, %c32_i256 : i256 +// CHECK-NEXT: %48 = arith.addi %arg2, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %47, %48 : i256, i256 // CHECK-NEXT: } -// CHECK-NEXT: %41 = arith.subi %39, %29 : i256 -// CHECK-NEXT: %42 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%42, %41) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %42 = arith.subi %40, %30 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %42) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -553,138 +645,162 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c192_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = arith.cmpi sle, %2, %c35_i256 : i256 // CHECK-NEXT: scf.if %13 { -// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 -// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %29 = arith.addi %27, %c4_i256 : i256 +// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %31 = arith.addi %27, %c36_i256 : i256 +// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %33 = arith.addi %27, %c68_i256 : i256 +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %35 = arith.addi %27, %c100_i256 : i256 +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%37, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> // CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %16 = arith.addi %15, %c64_i256 : i256 -// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %18 = arith.cmpi ult, %2, %c196_i256 : i256 -// CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 -// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %15 : i256 +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %19:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %15, %arg2 = %c4_i256) -> (i256, i256) { -// CHECK-NEXT: %23 = arith.addi %arg2, %c31_i256 : i256 -// CHECK-NEXT: %24 = arith.cmpi sge, %23, %2 : i256 -// CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %38 = arith.addi %36, %c4_i256 : i256 -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %40 = arith.addi %36, %c36_i256 : i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %36, %c68_i256 : i256 +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %21 = arith.cmpi ult, %2, %c196_i256 : i256 +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %29 = arith.addi %27, %c4_i256 : i256 +// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %31 = arith.addi %27, %c36_i256 : i256 +// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %33 = arith.addi %27, %c68_i256 : i256 +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %35 = arith.addi %27, %c100_i256 : i256 +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%37, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %22:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %15, %arg2 = %c4_i256) -> (i256, i256) { +// CHECK-NEXT: %26 = arith.addi %arg2, %c31_i256 : i256 +// CHECK-NEXT: %27 = arith.cmpi sge, %26, %2 : i256 +// CHECK-NEXT: scf.if %27 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %36, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%46, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %27 = arith.addi %26, %c96_i256 : i256 // CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %29 = arith.addi %arg2, %c96_i256 : i256 -// CHECK-NEXT: %30 = arith.cmpi ugt, %29, %2 : i256 -// CHECK-NEXT: scf.if %30 { -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %38 = arith.addi %36, %c4_i256 : i256 -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %40 = arith.addi %36, %c36_i256 : i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %36, %c68_i256 : i256 +// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %30 = arith.addi %29, %c96_i256 : i256 +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %29 : i256 +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %35 = arith.addi %arg2, %c96_i256 : i256 +// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %2 : i256 +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %36, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%46, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %31:2 = scf.for %arg3 = %c0 to %c3 step %c1 iter_args(%arg4 = %26, %arg5 = %arg2) -> (i256, i256) { -// CHECK-NEXT: %35 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %37 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %36, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %38 = arith.addi %arg4, %c32_i256 : i256 -// CHECK-NEXT: %39 = arith.addi %arg5, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %38, %39 : i256, i256 +// CHECK-NEXT: %37:2 = scf.for %arg3 = %c0 to %c3 step %c1 iter_args(%arg4 = %29, %arg5 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %41 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %43 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %42, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = arith.addi %arg4, %c32_i256 : i256 +// CHECK-NEXT: %45 = arith.addi %arg5, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %44, %45 : i256, i256 // CHECK-NEXT: } -// CHECK-NEXT: %32 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %26, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %33 = arith.addi %arg1, %c32_i256 : i256 -// CHECK-NEXT: %34 = arith.addi %arg2, %c96_i256 : i256 -// CHECK-NEXT: scf.yield %33, %34 : i256, i256 +// CHECK-NEXT: %38 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %29, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %39 = arith.addi %arg1, %c32_i256 : i256 +// CHECK-NEXT: %40 = arith.addi %arg2, %c96_i256 : i256 +// CHECK-NEXT: scf.yield %39, %40 : i256, i256 // CHECK-NEXT: } // CHECK-NEXT: func.call @m2s_stat2d_101(%15) : (i256) -> () -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%22, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%25, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -692,63 +808,63 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%39, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%39, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %40, %c4_i256 : i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %40, %c36_i256 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c34_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %40, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %40, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%50, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c34_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 // CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 // CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %40, %c4_i256 : i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %40, %c36_i256 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %40, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %40, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%50, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> @@ -758,164 +874,190 @@ contract ArrayCopy { // CHECK-NEXT: %23 = arith.addi %21, %22 : i256 // CHECK-NEXT: %24 = arith.cmpi ugt, %23, %2 : i256 // CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = arith.addi %40, %c4_i256 : i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %40, %c36_i256 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %40, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %40, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%50, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %25 = arith.muli %20, %c32_i256 : i256 // CHECK-NEXT: %26 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %26 { -// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %40 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c65_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%41, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %27 = arith.addi %25, %c32_i256 : i256 -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %30 = arith.addi %29, %27 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %20, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %33 = arith.addi %29, %c32_i256 : i256 -// CHECK-NEXT: %34 = arith.index_castui %20 : i256 to index -// CHECK-NEXT: %35:2 = scf.for %arg0 = %c0 to %34 step %c1 iter_args(%arg1 = %33, %arg2 = %21) -> (i256, i256) { -// CHECK-NEXT: %39 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %41 = arith.cmpi ugt, %40, %c18446744073709551615_i256 : i256 -// CHECK-NEXT: scf.if %41 { -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %68 = arith.addi %66, %c4_i256 : i256 -// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %70 = arith.addi %66, %c36_i256 : i256 -// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %72 = arith.addi %66, %c68_i256 : i256 -// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %74 = arith.addi %66, %c100_i256 : i256 +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %29 = arith.addi %25, %c63_i256 : i256 +// CHECK-NEXT: %30 = arith.andi %29, %c-32_i256 : i256 +// CHECK-NEXT: %31 = arith.addi %28, %30 : i256 +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %28 : i256 +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %36 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %20, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = arith.addi %28, %c32_i256 : i256 +// CHECK-NEXT: %38 = arith.index_castui %20 : i256 to index +// CHECK-NEXT: %39:2 = scf.for %arg0 = %c0 to %38 step %c1 iter_args(%arg1 = %37, %arg2 = %21) -> (i256, i256) { +// CHECK-NEXT: %43 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %45 = arith.cmpi ugt, %44, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: scf.if %45 { +// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %76 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%76, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %82 = arith.addi %74, %c100_i256 : i256 +// CHECK-NEXT: %83 = llvm.inttoptr %82 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%84, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %42 = arith.addi %21, %40 : i256 -// CHECK-NEXT: %43 = arith.addi %42, %c31_i256 : i256 -// CHECK-NEXT: %44 = arith.cmpi sge, %43, %2 : i256 -// CHECK-NEXT: scf.if %44 { -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %68 = arith.addi %66, %c4_i256 : i256 -// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %70 = arith.addi %66, %c36_i256 : i256 -// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %72 = arith.addi %66, %c68_i256 : i256 -// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %74 = arith.addi %66, %c100_i256 : i256 +// CHECK-NEXT: %46 = arith.addi %21, %44 : i256 +// CHECK-NEXT: %47 = arith.addi %46, %c31_i256 : i256 +// CHECK-NEXT: %48 = arith.cmpi sge, %47, %2 : i256 +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %76 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%76, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %82 = arith.addi %74, %c100_i256 : i256 +// CHECK-NEXT: %83 = llvm.inttoptr %82 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%84, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %45 = llvm.inttoptr %42 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %47 = arith.addi %42, %c32_i256 : i256 -// CHECK-NEXT: %48 = arith.muli %46, %c32_i256 : i256 -// CHECK-NEXT: %49 = arith.addi %47, %48 : i256 -// CHECK-NEXT: %50 = arith.cmpi ugt, %49, %2 : i256 -// CHECK-NEXT: scf.if %50 { -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %68 = arith.addi %66, %c4_i256 : i256 -// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %70 = arith.addi %66, %c36_i256 : i256 -// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %72 = arith.addi %66, %c68_i256 : i256 -// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %74 = arith.addi %66, %c100_i256 : i256 +// CHECK-NEXT: %49 = llvm.inttoptr %46 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %51 = arith.addi %46, %c32_i256 : i256 +// CHECK-NEXT: %52 = arith.muli %50, %c32_i256 : i256 +// CHECK-NEXT: %53 = arith.addi %51, %52 : i256 +// CHECK-NEXT: %54 = arith.cmpi ugt, %53, %2 : i256 +// CHECK-NEXT: scf.if %54 { +// CHECK-NEXT: %73 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %76 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%76, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %76 = arith.addi %74, %c4_i256 : i256 +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %78 = arith.addi %74, %c36_i256 : i256 +// CHECK-NEXT: %79 = llvm.inttoptr %78 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %80 = arith.addi %74, %c68_i256 : i256 +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %82 = arith.addi %74, %c100_i256 : i256 +// CHECK-NEXT: %83 = llvm.inttoptr %82 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %83 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %84 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%84, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %51 = arith.muli %46, %c32_i256 : i256 -// CHECK-NEXT: %52 = arith.cmpi ugt, %46, %c18446744073709551615_i256 : i256 -// CHECK-NEXT: scf.if %52 { -// CHECK-NEXT: %65 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %66 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c65_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %67 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%67, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %55 = arith.muli %50, %c32_i256 : i256 +// CHECK-NEXT: %56 = arith.cmpi ugt, %50, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: scf.if %56 { +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %74 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %75 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%75, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %53 = arith.addi %51, %c32_i256 : i256 -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %56 = arith.addi %55, %53 : i256 // CHECK-NEXT: %57 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %56, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %58 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %46, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %59 = arith.addi %55, %c32_i256 : i256 -// CHECK-NEXT: %60 = arith.index_castui %46 : i256 to index -// CHECK-NEXT: %61:2 = scf.for %arg3 = %c0 to %60 step %c1 iter_args(%arg4 = %59, %arg5 = %47) -> (i256, i256) { -// CHECK-NEXT: %65 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %67 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %66, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %68 = arith.addi %arg4, %c32_i256 : i256 -// CHECK-NEXT: %69 = arith.addi %arg5, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %68, %69 : i256, i256 +// CHECK-NEXT: %58 = llvm.load %57 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %59 = arith.addi %55, %c63_i256 : i256 +// CHECK-NEXT: %60 = arith.andi %59, %c-32_i256 : i256 +// CHECK-NEXT: %61 = arith.addi %58, %60 : i256 +// CHECK-NEXT: %62 = arith.cmpi ugt, %61, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %63 = arith.cmpi ult, %61, %58 : i256 +// CHECK-NEXT: %64 = arith.ori %62, %63 : i1 +// CHECK-NEXT: scf.if %64 { +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %74 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %75 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%75, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %62 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %55, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %63 = arith.addi %arg1, %c32_i256 : i256 -// CHECK-NEXT: %64 = arith.addi %arg2, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %63, %64 : i256, i256 -// CHECK-NEXT: } -// CHECK-NEXT: func.call @m2s_dyn2d_113(%29) : (i256) -> () -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%38, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %61, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %66 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %50, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %67 = arith.addi %58, %c32_i256 : i256 +// CHECK-NEXT: %68 = arith.index_castui %50 : i256 to index +// CHECK-NEXT: %69:2 = scf.for %arg3 = %c0 to %68 step %c1 iter_args(%arg4 = %67, %arg5 = %51) -> (i256, i256) { +// CHECK-NEXT: %73 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %74 = llvm.load %73 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %75 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %74, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %76 = arith.addi %arg4, %c32_i256 : i256 +// CHECK-NEXT: %77 = arith.addi %arg5, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %76, %77 : i256, i256 +// CHECK-NEXT: } +// CHECK-NEXT: %70 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %58, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %71 = arith.addi %arg1, %c32_i256 : i256 +// CHECK-NEXT: %72 = arith.addi %arg2, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %71, %72 : i256, i256 +// CHECK-NEXT: } +// CHECK-NEXT: func.call @m2s_dyn2d_113(%28) : (i256) -> () +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -1012,38 +1154,60 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%18, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c192_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%18, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %13 = func.call @cd2m_stat2d_153(%c4_i256) : (i256) -> i256 -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %16:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %15, %arg2 = %13) -> (i256, i256) { -// CHECK-NEXT: %18 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %20:2 = scf.for %arg3 = %c0 to %c3 step %c1 iter_args(%arg4 = %arg1, %arg5 = %19) -> (i256, i256) { -// CHECK-NEXT: %23 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %25 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %26 = arith.addi %arg4, %c32_i256 : i256 -// CHECK-NEXT: %27 = arith.addi %arg5, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %26, %27 : i256, i256 +// CHECK-NEXT: %13 = arith.cmpi ult, %2, %c196_i256 : i256 +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %22 = arith.addi %20, %c4_i256 : i256 +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %24 = arith.addi %20, %c36_i256 : i256 +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %26 = arith.addi %20, %c68_i256 : i256 +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %28 = arith.addi %20, %c100_i256 : i256 +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %30 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%30, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %14 = func.call @cd2m_stat2d_153(%c4_i256) : (i256) -> i256 +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %17:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %16, %arg2 = %14) -> (i256, i256) { +// CHECK-NEXT: %19 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %21:2 = scf.for %arg3 = %c0 to %c3 step %c1 iter_args(%arg4 = %arg1, %arg5 = %20) -> (i256, i256) { +// CHECK-NEXT: %24 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %26 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %27 = arith.addi %arg4, %c32_i256 : i256 +// CHECK-NEXT: %28 = arith.addi %arg5, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %27, %28 : i256, i256 // CHECK-NEXT: } -// CHECK-NEXT: %21 = arith.addi %arg1, %c96_i256 : i256 -// CHECK-NEXT: %22 = arith.addi %arg2, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %21, %22 : i256, i256 +// CHECK-NEXT: %22 = arith.addi %arg1, %c96_i256 : i256 +// CHECK-NEXT: %23 = arith.addi %arg2, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %22, %23 : i256, i256 // CHECK-NEXT: } -// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%17, %c192_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %18 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%18, %c192_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -1051,140 +1215,162 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%44, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%44, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 -// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c34_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c34_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () -// CHECK-NEXT: } -// CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 -// CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 -// CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 -// CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 -// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: } +// CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 +// CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 +// CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> // CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %21 = arith.addi %14, %c36_i256 : i256 -// CHECK-NEXT: %22 = arith.muli %20, %c32_i256 : i256 -// CHECK-NEXT: %23 = arith.addi %21, %22 : i256 -// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %2 : i256 -// CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 -// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %22 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038840874448248112245855622722229435958027532839407121884968680161280_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %25 = llvm.insertvalue %21, %0[0] : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %26 = llvm.insertvalue %20, %25[1] : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %27 = func.call @cd2m_dyn2d_167(%26) : (!llvm.struct<(i256, i256)>) -> i256 -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %30 = arith.addi %29, %c32_i256 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %34 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %35 = arith.index_castui %33 : i256 to index -// CHECK-NEXT: %36 = arith.addi %29, %c64_i256 : i256 -// CHECK-NEXT: %37 = arith.addi %27, %c32_i256 : i256 -// CHECK-NEXT: %38 = arith.muli %33, %c32_i256 : i256 -// CHECK-NEXT: %39 = arith.addi %36, %38 : i256 -// CHECK-NEXT: %40:3 = scf.for %arg0 = %c0 to %35 step %c1 iter_args(%arg1 = %36, %arg2 = %37, %arg3 = %39) -> (i256, i256, i256) { -// CHECK-NEXT: %43 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = arith.subi %arg3, %36 : i256 -// CHECK-NEXT: %46 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %45, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %47 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %49 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %48, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.index_castui %48 : i256 to index -// CHECK-NEXT: %51 = arith.addi %arg3, %c32_i256 : i256 -// CHECK-NEXT: %52 = arith.addi %44, %c32_i256 : i256 -// CHECK-NEXT: %53 = arith.muli %48, %c32_i256 : i256 -// CHECK-NEXT: %54 = arith.addi %51, %53 : i256 -// CHECK-NEXT: %55:2 = scf.for %arg4 = %c0 to %50 step %c1 iter_args(%arg5 = %51, %arg6 = %52) -> (i256, i256) { -// CHECK-NEXT: %58 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %60 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %59, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %61 = arith.addi %arg5, %c32_i256 : i256 -// CHECK-NEXT: %62 = arith.addi %arg6, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %61, %62 : i256, i256 +// CHECK-NEXT: %23 = arith.muli %20, %c32_i256 : i256 +// CHECK-NEXT: %24 = arith.addi %21, %23 : i256 +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %2 : i256 +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = arith.addi %45, %c4_i256 : i256 +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %49 = arith.addi %45, %c36_i256 : i256 +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c43_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.addi %45, %c68_i256 : i256 +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %53 = arith.addi %45, %c100_i256 : i256 +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %55 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%55, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %26 = llvm.insertvalue %21, %0[0] : !llvm.struct<(i256, i256)> +// CHECK-NEXT: %27 = llvm.insertvalue %20, %26[1] : !llvm.struct<(i256, i256)> +// CHECK-NEXT: %28 = func.call @cd2m_dyn2d_167(%27) : (!llvm.struct<(i256, i256)>) -> i256 +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %31 = arith.addi %30, %c32_i256 : i256 +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c32_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %33 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %35 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %36 = arith.index_castui %34 : i256 to index +// CHECK-NEXT: %37 = arith.addi %30, %c64_i256 : i256 +// CHECK-NEXT: %38 = arith.addi %28, %c32_i256 : i256 +// CHECK-NEXT: %39 = arith.muli %34, %c32_i256 : i256 +// CHECK-NEXT: %40 = arith.addi %37, %39 : i256 +// CHECK-NEXT: %41:3 = scf.for %arg0 = %c0 to %36 step %c1 iter_args(%arg1 = %37, %arg2 = %38, %arg3 = %40) -> (i256, i256, i256) { +// CHECK-NEXT: %44 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %46 = arith.subi %arg3, %37 : i256 +// CHECK-NEXT: %47 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %46, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %50 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %49, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %51 = arith.index_castui %49 : i256 to index +// CHECK-NEXT: %52 = arith.addi %arg3, %c32_i256 : i256 +// CHECK-NEXT: %53 = arith.addi %45, %c32_i256 : i256 +// CHECK-NEXT: %54 = arith.muli %49, %c32_i256 : i256 +// CHECK-NEXT: %55 = arith.addi %52, %54 : i256 +// CHECK-NEXT: %56:2 = scf.for %arg4 = %c0 to %51 step %c1 iter_args(%arg5 = %52, %arg6 = %53) -> (i256, i256) { +// CHECK-NEXT: %59 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %60 = llvm.load %59 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %61 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %60, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %62 = arith.addi %arg5, %c32_i256 : i256 +// CHECK-NEXT: %63 = arith.addi %arg6, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %62, %63 : i256, i256 // CHECK-NEXT: } -// CHECK-NEXT: %56 = arith.addi %arg1, %c32_i256 : i256 -// CHECK-NEXT: %57 = arith.addi %arg2, %c32_i256 : i256 -// CHECK-NEXT: scf.yield %56, %57, %54 : i256, i256, i256 +// CHECK-NEXT: %57 = arith.addi %arg1, %c32_i256 : i256 +// CHECK-NEXT: %58 = arith.addi %arg2, %c32_i256 : i256 +// CHECK-NEXT: scf.yield %57, %58, %55 : i256, i256, i256 // CHECK-NEXT: } -// CHECK-NEXT: %41 = arith.subi %40#2, %29 : i256 -// CHECK-NEXT: %42 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%42, %41) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %42 = arith.subi %41#2, %30 : i256 +// CHECK-NEXT: %43 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %42) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -1192,63 +1378,63 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c34_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c34_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 // CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 // CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c43_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> @@ -1257,58 +1443,71 @@ contract ArrayCopy { // CHECK-NEXT: %22 = arith.addi %21, %20 : i256 // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %2 : i256 // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c39_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c39_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %24 = arith.addi %20, %c31_i256 : i256 // CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 // CHECK-NEXT: %26 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %26 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %29 = arith.addi %25, %c63_i256 : i256 +// CHECK-NEXT: %30 = arith.andi %29, %c-32_i256 : i256 +// CHECK-NEXT: %31 = arith.addi %28, %30 : i256 +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %28 : i256 +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %27 = arith.addi %25, %c32_i256 : i256 -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %30 = arith.addi %29, %27 : i256 -// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %32 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %20, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %33 = arith.addi %29, %c32_i256 : i256 -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %35 = llvm.inttoptr %21 : i256 to !llvm.ptr<2> -// CHECK-NEXT: "llvm.intr.memcpy"(%34, %35, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () -// CHECK-NEXT: %36 = arith.addi %33, %20 : i256 -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c0_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: func.call @m2s_str_177(%29) : (i256) -> () -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%40, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %36 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %20, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = arith.addi %28, %c32_i256 : i256 +// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %39 = llvm.inttoptr %21 : i256 to !llvm.ptr<2> +// CHECK-NEXT: "llvm.intr.memcpy"(%38, %39, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () +// CHECK-NEXT: %40 = arith.addi %37, %20 : i256 +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c0_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: func.call @m2s_str_177(%28) : (i256) -> () +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%44, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -1316,8 +1515,8 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = func.call @s2m_str_185() : () -> i256 @@ -1333,14 +1532,17 @@ contract ArrayCopy { // CHECK-NEXT: %20 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> // CHECK-NEXT: %21 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> // CHECK-NEXT: "llvm.intr.memmove"(%20, %21, %18) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () -// CHECK-NEXT: %22 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %18, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %23 = arith.addi %18, %c31_i256 : i256 -// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 -// CHECK-NEXT: %25 = arith.addi %16, %24 : i256 -// CHECK-NEXT: %26 = arith.subi %25, %13 : i256 -// CHECK-NEXT: %27 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%27, %26) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %22 = arith.addi %16, %18 : i256 +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c0_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %24 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %18, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %25 = arith.addi %18, %c31_i256 : i256 +// CHECK-NEXT: %26 = arith.andi %25, %c-32_i256 : i256 +// CHECK-NEXT: %27 = arith.addi %16, %26 : i256 +// CHECK-NEXT: %28 = arith.subi %27, %13 : i256 +// CHECK-NEXT: %29 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%29, %28) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -1348,63 +1550,63 @@ contract ArrayCopy { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 // CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c34_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c34_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 // CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 // CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 // CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c43_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 // CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> @@ -1413,24 +1615,24 @@ contract ArrayCopy { // CHECK-NEXT: %22 = arith.addi %21, %20 : i256 // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %2 : i256 // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c39_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 +// CHECK-NEXT: llvm.store %c39_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 // CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %24 = llvm.insertvalue %21, %0[0] : !llvm.struct<(i256, i256)> @@ -1448,14 +1650,17 @@ contract ArrayCopy { // CHECK-NEXT: %35 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> // CHECK-NEXT: %36 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> // CHECK-NEXT: "llvm.intr.memmove"(%35, %36, %33) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () -// CHECK-NEXT: %37 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %33, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %38 = arith.addi %33, %c31_i256 : i256 -// CHECK-NEXT: %39 = arith.andi %38, %c-32_i256 : i256 -// CHECK-NEXT: %40 = arith.addi %31, %39 : i256 -// CHECK-NEXT: %41 = arith.subi %40, %28 : i256 -// CHECK-NEXT: %42 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%42, %41) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %37 = arith.addi %31, %33 : i256 +// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c0_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %39 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %33, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %40 = arith.addi %33, %c31_i256 : i256 +// CHECK-NEXT: %41 = arith.andi %40, %c-32_i256 : i256 +// CHECK-NEXT: %42 = arith.addi %31, %41 : i256 +// CHECK-NEXT: %43 = arith.subi %42, %28 : i256 +// CHECK-NEXT: %44 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%44, %43) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: scf.yield // CHECK-NEXT: } @@ -1469,6 +1674,13 @@ contract ArrayCopy { // CHECK-NEXT: llvm.unreachable // CHECK-NEXT: } // CHECK-NEXT: func.func @cd2m_str_195(%arg0: !llvm.struct<(i256, i256)>) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 @@ -1480,25 +1692,41 @@ contract ArrayCopy { // CHECK-NEXT: %2 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> // CHECK-NEXT: %3 = arith.addi %2, %c31_i256 : i256 // CHECK-NEXT: %4 = arith.andi %3, %c-32_i256 : i256 -// CHECK-NEXT: %5 = arith.addi %4, %c32_i256 : i256 -// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %2, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %11 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %12 = arith.addi %7, %c32_i256 : i256 -// CHECK-NEXT: %13 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %14 = llvm.inttoptr %11 : i256 to !llvm.ptr<2> -// CHECK-NEXT: "llvm.intr.memcpy"(%13, %14, %2) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () -// CHECK-NEXT: return %7 : i256 +// CHECK-NEXT: %5 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %7 = arith.addi %4, %c63_i256 : i256 +// CHECK-NEXT: %8 = arith.andi %7, %c-32_i256 : i256 +// CHECK-NEXT: %9 = arith.addi %6, %8 : i256 +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %6 : i256 +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %14 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %2, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %15 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> +// CHECK-NEXT: %16 = arith.addi %6, %c32_i256 : i256 +// CHECK-NEXT: %17 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> +// CHECK-NEXT: "llvm.intr.memcpy"(%17, %18, %2) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () +// CHECK-NEXT: return %6 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @s2m_str_185() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 // CHECK-NEXT: %c32 = arith.constant 32 : index // CHECK-NEXT: %c0 = arith.constant 0 : index // CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 @@ -1522,51 +1750,64 @@ contract ArrayCopy { // CHECK-NEXT: %8 = arith.trunci %3 : i256 to i1 // CHECK-NEXT: %9 = arith.cmpi eq, %8, %7 : i1 // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %23 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c34_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: "llvm.intrcall"(%24, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c34_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () // CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: %10 = arith.addi %6, %c31_i256 : i256 // CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 -// CHECK-NEXT: %12 = arith.addi %11, %c32_i256 : i256 -// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %15 = arith.addi %14, %12 : i256 -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %6, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %18 = arith.addi %14, %c32_i256 : i256 -// CHECK-NEXT: %19 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %6, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %20 = arith.andi %1, %c1_i256 : i256 -// CHECK-NEXT: %21 = arith.cmpi eq, %20, %c0_i256 : i256 -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %22 = arith.andi %1, %c-256_i256 : i256 -// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %14 = arith.addi %11, %c63_i256 : i256 +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 +// CHECK-NEXT: %16 = arith.addi %13, %15 : i256 +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %13 : i256 +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %6, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %22 = arith.addi %13, %c32_i256 : i256 +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %6, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %24 = arith.andi %1, %c1_i256 : i256 +// CHECK-NEXT: %25 = arith.cmpi eq, %24, %c0_i256 : i256 +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %26 = arith.andi %1, %c-256_i256 : i256 +// CHECK-NEXT: %27 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } else { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c11_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %24 = "llvm.intrcall"(%23, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 -// CHECK-NEXT: %25 = arith.index_castui %6 : i256 to index -// CHECK-NEXT: scf.for %arg0 = %c0 to %25 step %c32 { -// CHECK-NEXT: %26 = arith.index_castui %arg0 : index to i256 -// CHECK-NEXT: %27 = arith.divui %26, %c32_i256 : i256 -// CHECK-NEXT: %28 = arith.addi %24, %27 : i256 -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<5> -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 -// CHECK-NEXT: %31 = arith.addi %18, %26 : i256 -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %30, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c11_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %28 = "llvm.intrcall"(%27, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 +// CHECK-NEXT: %29 = arith.index_castui %6 : i256 to index +// CHECK-NEXT: scf.for %arg0 = %c0 to %29 step %c32 { +// CHECK-NEXT: %30 = arith.index_castui %arg0 : index to i256 +// CHECK-NEXT: %31 = arith.divui %30, %c32_i256 : i256 +// CHECK-NEXT: %32 = arith.addi %28, %31 : i256 +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<5> +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 +// CHECK-NEXT: %35 = arith.addi %22, %30 : i256 +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %34, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } // CHECK-NEXT: } -// CHECK-NEXT: return %14 : i256 +// CHECK-NEXT: return %13 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @m2s_str_177(%arg0: i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 @@ -1693,8 +1934,16 @@ contract ArrayCopy { // CHECK-NEXT: return // CHECK-NEXT: } // CHECK-NEXT: func.func @cd2m_dyn2d_167(%arg0: !llvm.struct<(i256, i256)>) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 @@ -1703,55 +1952,81 @@ contract ArrayCopy { // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> // CHECK-NEXT: %2 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> // CHECK-NEXT: %3 = arith.muli %2, %c32_i256 : i256 -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 -// CHECK-NEXT: %5 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %7 = arith.addi %6, %4 : i256 -// CHECK-NEXT: %8 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %2, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %10 = arith.addi %6, %c32_i256 : i256 -// CHECK-NEXT: %11 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %12 = arith.index_castui %2 : i256 to index -// CHECK-NEXT: scf.for %arg1 = %c0 to %12 step %c1 { -// CHECK-NEXT: %13 = arith.index_castui %arg1 : index to i256 -// CHECK-NEXT: %14 = arith.muli %13, %c32_i256 : i256 -// CHECK-NEXT: %15 = arith.addi %11, %14 : i256 -// CHECK-NEXT: %16 = arith.muli %13, %c32_i256 : i256 -// CHECK-NEXT: %17 = arith.addi %10, %16 : i256 -// CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %20 = arith.addi %11, %19 : i256 -// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %23 = arith.addi %20, %c32_i256 : i256 -// CHECK-NEXT: %24 = arith.muli %22, %c32_i256 : i256 -// CHECK-NEXT: %25 = arith.addi %24, %c32_i256 : i256 -// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %28 = arith.addi %27, %25 : i256 +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %6 = arith.addi %3, %c63_i256 : i256 +// CHECK-NEXT: %7 = arith.andi %6, %c-32_i256 : i256 +// CHECK-NEXT: %8 = arith.addi %5, %7 : i256 +// CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %10 = arith.cmpi ult, %8, %5 : i256 +// CHECK-NEXT: %11 = arith.ori %9, %10 : i1 +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %8, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %2, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %14 = arith.addi %5, %c32_i256 : i256 +// CHECK-NEXT: %15 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> +// CHECK-NEXT: %16 = arith.index_castui %2 : i256 to index +// CHECK-NEXT: scf.for %arg1 = %c0 to %16 step %c1 { +// CHECK-NEXT: %17 = arith.index_castui %arg1 : index to i256 +// CHECK-NEXT: %18 = arith.muli %17, %c32_i256 : i256 +// CHECK-NEXT: %19 = arith.addi %15, %18 : i256 +// CHECK-NEXT: %20 = arith.muli %17, %c32_i256 : i256 +// CHECK-NEXT: %21 = arith.addi %14, %20 : i256 +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %27 = arith.addi %24, %c32_i256 : i256 +// CHECK-NEXT: %28 = arith.muli %26, %c32_i256 : i256 // CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %30 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %22, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %31 = arith.addi %27, %c32_i256 : i256 -// CHECK-NEXT: %32 = arith.index_castui %22 : i256 to index -// CHECK-NEXT: scf.for %arg2 = %c0 to %32 step %c1 { -// CHECK-NEXT: %34 = arith.index_castui %arg2 : index to i256 -// CHECK-NEXT: %35 = arith.muli %34, %c32_i256 : i256 -// CHECK-NEXT: %36 = arith.addi %23, %35 : i256 -// CHECK-NEXT: %37 = arith.muli %34, %c32_i256 : i256 -// CHECK-NEXT: %38 = arith.addi %31, %37 : i256 -// CHECK-NEXT: %39 = llvm.inttoptr %36 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %41 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %31 = arith.addi %28, %c63_i256 : i256 +// CHECK-NEXT: %32 = arith.andi %31, %c-32_i256 : i256 +// CHECK-NEXT: %33 = arith.addi %30, %32 : i256 +// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %35 = arith.cmpi ult, %33, %30 : i256 +// CHECK-NEXT: %36 = arith.ori %34, %35 : i1 +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: %33 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %27, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %33, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %38 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %26, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %39 = arith.addi %30, %c32_i256 : i256 +// CHECK-NEXT: %40 = arith.index_castui %26 : i256 to index +// CHECK-NEXT: scf.for %arg2 = %c0 to %40 step %c1 { +// CHECK-NEXT: %42 = arith.index_castui %arg2 : index to i256 +// CHECK-NEXT: %43 = arith.muli %42, %c32_i256 : i256 +// CHECK-NEXT: %44 = arith.addi %27, %43 : i256 +// CHECK-NEXT: %45 = arith.muli %42, %c32_i256 : i256 +// CHECK-NEXT: %46 = arith.addi %39, %45 : i256 +// CHECK-NEXT: %47 = llvm.inttoptr %44 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %49 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %48, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: } +// CHECK-NEXT: %41 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %30, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } -// CHECK-NEXT: return %6 : i256 +// CHECK-NEXT: return %5 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @cd2m_stat2d_153(%arg0: i256) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c3 = arith.constant 3 : index @@ -1760,6 +2035,12 @@ contract ArrayCopy { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr @@ -1768,134 +2049,220 @@ contract ArrayCopy { // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %4 = arith.addi %3, %c64_i256 : i256 -// CHECK-NEXT: %5 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %5 = arith.cmpi ugt, %4, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %6 = arith.cmpi ult, %4, %3 : i256 +// CHECK-NEXT: %7 = arith.ori %5, %6 : i1 +// CHECK-NEXT: scf.if %7 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %10 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%11, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %8 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %4, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: scf.for %arg1 = %c0 to %c2 step %c1 { -// CHECK-NEXT: %6 = arith.index_castui %arg1 : index to i256 -// CHECK-NEXT: %7 = arith.muli %6, %c96_i256 : i256 -// CHECK-NEXT: %8 = arith.addi %1, %7 : i256 -// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 -// CHECK-NEXT: %10 = arith.addi %3, %9 : i256 -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %13 = arith.addi %12, %c96_i256 : i256 +// CHECK-NEXT: %9 = arith.index_castui %arg1 : index to i256 +// CHECK-NEXT: %10 = arith.muli %9, %c96_i256 : i256 +// CHECK-NEXT: %11 = arith.addi %1, %10 : i256 +// CHECK-NEXT: %12 = arith.muli %9, %c32_i256 : i256 +// CHECK-NEXT: %13 = arith.addi %3, %12 : i256 // CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %16 = arith.addi %15, %c96_i256 : i256 +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %15 : i256 +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %23 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%24, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: scf.for %arg2 = %c0 to %c3 step %c1 { -// CHECK-NEXT: %16 = arith.index_castui %arg2 : index to i256 -// CHECK-NEXT: %17 = arith.muli %16, %c32_i256 : i256 -// CHECK-NEXT: %18 = arith.addi %8, %17 : i256 -// CHECK-NEXT: %19 = arith.muli %16, %c32_i256 : i256 -// CHECK-NEXT: %20 = arith.addi %12, %19 : i256 -// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %23 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %22 = arith.index_castui %arg2 : index to i256 +// CHECK-NEXT: %23 = arith.muli %22, %c32_i256 : i256 +// CHECK-NEXT: %24 = arith.addi %11, %23 : i256 +// CHECK-NEXT: %25 = arith.muli %22, %c32_i256 : i256 +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 +// CHECK-NEXT: %27 = llvm.inttoptr %24 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %29 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } -// CHECK-NEXT: %15 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %12, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %15, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } // CHECK-NEXT: return %3 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @s2m_dyn2d_135() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c10_i256 = arith.constant 10 : i256 // CHECK-NEXT: %0 = llvm.inttoptr %c10_i256 : i256 to !llvm.ptr<5> // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 // CHECK-NEXT: %2 = arith.muli %1, %c32_i256 : i256 -// CHECK-NEXT: %3 = arith.addi %2, %c32_i256 : i256 -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %6 = arith.addi %5, %3 : i256 -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %8 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %1, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %9 = arith.addi %5, %c32_i256 : i256 -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c10_i256, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %12 = "llvm.intrcall"(%11, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 -// CHECK-NEXT: %13 = arith.index_castui %1 : i256 to index -// CHECK-NEXT: scf.for %arg0 = %c0 to %13 step %c1 { -// CHECK-NEXT: %14 = arith.index_castui %arg0 : index to i256 -// CHECK-NEXT: %15 = arith.addi %12, %14 : i256 -// CHECK-NEXT: %16 = arith.muli %14, %c32_i256 : i256 -// CHECK-NEXT: %17 = arith.addi %9, %16 : i256 -// CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<5> -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 -// CHECK-NEXT: %20 = arith.muli %19, %c32_i256 : i256 -// CHECK-NEXT: %21 = arith.addi %20, %c32_i256 : i256 -// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %24 = arith.addi %23, %21 : i256 +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %5 = arith.addi %2, %c63_i256 : i256 +// CHECK-NEXT: %6 = arith.andi %5, %c-32_i256 : i256 +// CHECK-NEXT: %7 = arith.addi %4, %6 : i256 +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %4 : i256 +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %19 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%20, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %1, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %13 = arith.addi %4, %c32_i256 : i256 +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c10_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %16 = "llvm.intrcall"(%15, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 +// CHECK-NEXT: %17 = arith.index_castui %1 : i256 to index +// CHECK-NEXT: scf.for %arg0 = %c0 to %17 step %c1 { +// CHECK-NEXT: %18 = arith.index_castui %arg0 : index to i256 +// CHECK-NEXT: %19 = arith.addi %16, %18 : i256 +// CHECK-NEXT: %20 = arith.muli %18, %c32_i256 : i256 +// CHECK-NEXT: %21 = arith.addi %13, %20 : i256 +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<5> +// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 +// CHECK-NEXT: %24 = arith.muli %23, %c32_i256 : i256 // CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %19, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %27 = arith.addi %23, %c32_i256 : i256 -// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %15, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %30 = "llvm.intrcall"(%29, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 -// CHECK-NEXT: %31 = arith.index_castui %19 : i256 to index -// CHECK-NEXT: scf.for %arg1 = %c0 to %31 step %c1 { -// CHECK-NEXT: %33 = arith.index_castui %arg1 : index to i256 -// CHECK-NEXT: %34 = arith.addi %30, %33 : i256 -// CHECK-NEXT: %35 = arith.muli %33, %c32_i256 : i256 -// CHECK-NEXT: %36 = arith.addi %27, %35 : i256 -// CHECK-NEXT: %37 = llvm.inttoptr %34 : i256 to !llvm.ptr<5> -// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 -// CHECK-NEXT: %39 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %27 = arith.addi %24, %c63_i256 : i256 +// CHECK-NEXT: %28 = arith.andi %27, %c-32_i256 : i256 +// CHECK-NEXT: %29 = arith.addi %26, %28 : i256 +// CHECK-NEXT: %30 = arith.cmpi ugt, %29, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %31 = arith.cmpi ult, %29, %26 : i256 +// CHECK-NEXT: %32 = arith.ori %30, %31 : i1 +// CHECK-NEXT: scf.if %32 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %33 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %29, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %34 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %23, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %35 = arith.addi %26, %c32_i256 : i256 +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %19, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %38 = "llvm.intrcall"(%37, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 +// CHECK-NEXT: %39 = arith.index_castui %23 : i256 to index +// CHECK-NEXT: scf.for %arg1 = %c0 to %39 step %c1 { +// CHECK-NEXT: %41 = arith.index_castui %arg1 : index to i256 +// CHECK-NEXT: %42 = arith.addi %38, %41 : i256 +// CHECK-NEXT: %43 = arith.muli %41, %c32_i256 : i256 +// CHECK-NEXT: %44 = arith.addi %35, %43 : i256 +// CHECK-NEXT: %45 = llvm.inttoptr %42 : i256 to !llvm.ptr<5> +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 +// CHECK-NEXT: %47 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %46, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } -// CHECK-NEXT: %32 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %23, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %40 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %26, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } -// CHECK-NEXT: return %5 : i256 +// CHECK-NEXT: return %4 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @s2m_stat2d_125() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c3 = arith.constant 3 : index -// CHECK-NEXT: %c2 = arith.constant 2 : index // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 +// CHECK-NEXT: %c2 = arith.constant 2 : index // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %2 = arith.addi %1, %c64_i256 : i256 -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %2, %3 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %3 = arith.cmpi ugt, %2, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %4 = arith.cmpi ult, %2, %1 : i256 +// CHECK-NEXT: %5 = arith.ori %3, %4 : i1 +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %7 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %8 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%9, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %2, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: scf.for %arg0 = %c0 to %c2 step %c1 { -// CHECK-NEXT: %4 = arith.index_castui %arg0 : index to i256 -// CHECK-NEXT: %5 = arith.muli %4, %c3_i256 : i256 -// CHECK-NEXT: %6 = arith.addi %5, %c4_i256 : i256 -// CHECK-NEXT: %7 = arith.muli %4, %c32_i256 : i256 -// CHECK-NEXT: %8 = arith.addi %1, %7 : i256 -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %11 = arith.addi %10, %c96_i256 : i256 +// CHECK-NEXT: %7 = arith.index_castui %arg0 : index to i256 +// CHECK-NEXT: %8 = arith.muli %7, %c3_i256 : i256 +// CHECK-NEXT: %9 = arith.addi %8, %c4_i256 : i256 +// CHECK-NEXT: %10 = arith.muli %7, %c32_i256 : i256 +// CHECK-NEXT: %11 = arith.addi %1, %10 : i256 // CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %14 = arith.addi %13, %c96_i256 : i256 +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %16 = arith.cmpi ult, %14, %13 : i256 +// CHECK-NEXT: %17 = arith.ori %15, %16 : i1 +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: scf.for %arg1 = %c0 to %c3 step %c1 { -// CHECK-NEXT: %14 = arith.index_castui %arg1 : index to i256 -// CHECK-NEXT: %15 = arith.addi %6, %14 : i256 -// CHECK-NEXT: %16 = arith.muli %14, %c32_i256 : i256 -// CHECK-NEXT: %17 = arith.addi %10, %16 : i256 -// CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<5> -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 -// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %20 = arith.index_castui %arg1 : index to i256 +// CHECK-NEXT: %21 = arith.addi %9, %20 : i256 +// CHECK-NEXT: %22 = arith.muli %20, %c32_i256 : i256 +// CHECK-NEXT: %23 = arith.addi %13, %22 : i256 +// CHECK-NEXT: %24 = llvm.inttoptr %21 : i256 to !llvm.ptr<5> +// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 +// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } -// CHECK-NEXT: %13 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %10, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %19 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %13, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } // CHECK-NEXT: return %1 : i256 // CHECK-NEXT: } @@ -2062,8 +2429,16 @@ contract ArrayCopy { // CHECK-NEXT: return // CHECK-NEXT: } // CHECK-NEXT: func.func @cd2m_dyn_87(%arg0: !llvm.struct<(i256, i256)>) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 @@ -2072,37 +2447,56 @@ contract ArrayCopy { // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> // CHECK-NEXT: %2 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> // CHECK-NEXT: %3 = arith.muli %2, %c32_i256 : i256 -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 -// CHECK-NEXT: %5 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %7 = arith.addi %6, %4 : i256 -// CHECK-NEXT: %8 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %2, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %10 = arith.addi %6, %c32_i256 : i256 -// CHECK-NEXT: %11 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> -// CHECK-NEXT: %12 = arith.index_castui %2 : i256 to index -// CHECK-NEXT: scf.for %arg1 = %c0 to %12 step %c1 { -// CHECK-NEXT: %13 = arith.index_castui %arg1 : index to i256 -// CHECK-NEXT: %14 = arith.muli %13, %c32_i256 : i256 -// CHECK-NEXT: %15 = arith.addi %11, %14 : i256 -// CHECK-NEXT: %16 = arith.muli %13, %c32_i256 : i256 -// CHECK-NEXT: %17 = arith.addi %10, %16 : i256 -// CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %6 = arith.addi %3, %c63_i256 : i256 +// CHECK-NEXT: %7 = arith.andi %6, %c-32_i256 : i256 +// CHECK-NEXT: %8 = arith.addi %5, %7 : i256 +// CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %10 = arith.cmpi ult, %8, %5 : i256 +// CHECK-NEXT: %11 = arith.ori %9, %10 : i1 +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: return %6 : i256 +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %8, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %2, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %14 = arith.addi %5, %c32_i256 : i256 +// CHECK-NEXT: %15 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> +// CHECK-NEXT: %16 = arith.index_castui %2 : i256 to index +// CHECK-NEXT: scf.for %arg1 = %c0 to %16 step %c1 { +// CHECK-NEXT: %17 = arith.index_castui %arg1 : index to i256 +// CHECK-NEXT: %18 = arith.muli %17, %c32_i256 : i256 +// CHECK-NEXT: %19 = arith.addi %15, %18 : i256 +// CHECK-NEXT: %20 = arith.muli %17, %c32_i256 : i256 +// CHECK-NEXT: %21 = arith.addi %14, %20 : i256 +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %24 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: } +// CHECK-NEXT: return %5 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @cd2m_stat_75(%arg0: i256) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c3 = arith.constant 3 : index +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr @@ -2110,77 +2504,127 @@ contract ArrayCopy { // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %4 = arith.addi %3, %c96_i256 : i256 -// CHECK-NEXT: %5 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %5 = arith.cmpi ugt, %4, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %6 = arith.cmpi ult, %4, %3 : i256 +// CHECK-NEXT: %7 = arith.ori %5, %6 : i1 +// CHECK-NEXT: scf.if %7 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %10 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%11, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %8 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %4, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: scf.for %arg1 = %c0 to %c3 step %c1 { -// CHECK-NEXT: %6 = arith.index_castui %arg1 : index to i256 -// CHECK-NEXT: %7 = arith.muli %6, %c32_i256 : i256 -// CHECK-NEXT: %8 = arith.addi %1, %7 : i256 -// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 -// CHECK-NEXT: %10 = arith.addi %3, %9 : i256 -// CHECK-NEXT: %11 = llvm.inttoptr %8 : i256 to !llvm.ptr<2> -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 -// CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %9 = arith.index_castui %arg1 : index to i256 +// CHECK-NEXT: %10 = arith.muli %9, %c32_i256 : i256 +// CHECK-NEXT: %11 = arith.addi %1, %10 : i256 +// CHECK-NEXT: %12 = arith.muli %9, %c32_i256 : i256 +// CHECK-NEXT: %13 = arith.addi %3, %12 : i256 +// CHECK-NEXT: %14 = llvm.inttoptr %11 : i256 to !llvm.ptr<2> +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 +// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } // CHECK-NEXT: return %3 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @s2m_dyn_61() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 // CHECK-NEXT: %0 = llvm.inttoptr %c3_i256 : i256 to !llvm.ptr<5> // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 // CHECK-NEXT: %2 = arith.muli %1, %c32_i256 : i256 -// CHECK-NEXT: %3 = arith.addi %2, %c32_i256 : i256 -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 -// CHECK-NEXT: %6 = arith.addi %5, %3 : i256 -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %8 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %1, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %9 = arith.addi %5, %c32_i256 : i256 -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %c3_i256, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> -// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: %12 = "llvm.intrcall"(%11, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 -// CHECK-NEXT: %13 = arith.index_castui %1 : i256 to index -// CHECK-NEXT: scf.for %arg0 = %c0 to %13 step %c1 { -// CHECK-NEXT: %14 = arith.index_castui %arg0 : index to i256 -// CHECK-NEXT: %15 = arith.addi %12, %14 : i256 -// CHECK-NEXT: %16 = arith.muli %14, %c32_i256 : i256 -// CHECK-NEXT: %17 = arith.addi %9, %16 : i256 -// CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<5> -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 -// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 +// CHECK-NEXT: %5 = arith.addi %2, %c63_i256 : i256 +// CHECK-NEXT: %6 = arith.andi %5, %c-32_i256 : i256 +// CHECK-NEXT: %7 = arith.addi %4, %6 : i256 +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %4 : i256 +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %19 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%20, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: return %5 : i256 +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %1, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %13 = arith.addi %4, %c32_i256 : i256 +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c3_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: %16 = "llvm.intrcall"(%15, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 +// CHECK-NEXT: %17 = arith.index_castui %1 : i256 to index +// CHECK-NEXT: scf.for %arg0 = %c0 to %17 step %c1 { +// CHECK-NEXT: %18 = arith.index_castui %arg0 : index to i256 +// CHECK-NEXT: %19 = arith.addi %16, %18 : i256 +// CHECK-NEXT: %20 = arith.muli %18, %c32_i256 : i256 +// CHECK-NEXT: %21 = arith.addi %13, %20 : i256 +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<5> +// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 +// CHECK-NEXT: %24 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: } +// CHECK-NEXT: return %4 : i256 // CHECK-NEXT: } // CHECK-NEXT: func.func @s2m_stat_52() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c3 = arith.constant 3 : index +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 // CHECK-NEXT: %c1 = arith.constant 1 : index // CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 // CHECK-NEXT: %2 = arith.addi %1, %c96_i256 : i256 -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %2, %3 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %3 = arith.cmpi ugt, %2, %c18446744073709551615_i256 : i256 +// CHECK-NEXT: %4 = arith.cmpi ult, %2, %1 : i256 +// CHECK-NEXT: %5 = arith.ori %3, %4 : i1 +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %7 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %8 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %c65_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: "llvm.intrcall"(%9, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () +// CHECK-NEXT: func.call @".unreachable"() : () -> () +// CHECK-NEXT: } +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %2, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: scf.for %arg0 = %c0 to %c3 step %c1 { -// CHECK-NEXT: %4 = arith.index_castui %arg0 : index to i256 -// CHECK-NEXT: %5 = arith.muli %4, %c32_i256 : i256 -// CHECK-NEXT: %6 = arith.addi %1, %5 : i256 -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<5> -// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> +// CHECK-NEXT: %7 = arith.index_castui %arg0 : index to i256 +// CHECK-NEXT: %8 = arith.muli %7, %c32_i256 : i256 +// CHECK-NEXT: %9 = arith.addi %1, %8 : i256 +// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<5> +// CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 +// CHECK-NEXT: %12 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> +// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> // CHECK-NEXT: } // CHECK-NEXT: return %1 : i256 // CHECK-NEXT: } diff --git a/test/lit/mlirCodegen/EVM/array-decode.sol b/test/lit/mlirCodegen/EVM/array-decode.sol index cb976f298..c94f31842 100644 --- a/test/lit/mlirCodegen/EVM/array-decode.sol +++ b/test/lit/mlirCodegen/EVM/array-decode.sol @@ -85,6 +85,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -93,8 +100,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_272"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -102,22 +109,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_272() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_272_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_272_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_272_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_272_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -129,16 +150,17 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -172,63 +194,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -238,73 +260,86 @@ contract C { // CHECK-NEXT: %22 = arith.addi %20, %21 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.muli %19, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.index_castui %19 : i256 to index loc(#loc1) -// CHECK-NEXT: %34:2 = scf.for %arg0 = %c0 to %33 step %c1 iter_args(%arg1 = %32, %arg2 = %20) -> (i256, i256) { -// CHECK-NEXT: %41 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.trunci %42 : i256 to i8 loc(#loc1) -// CHECK-NEXT: %44 = arith.extui %43 : i8 to i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.cmpi ne, %42, %44 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %45 { -// CHECK-NEXT: %50 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%50, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.index_castui %19 : i256 to index loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg0 = %c0 to %37 step %c1 iter_args(%arg1 = %36, %arg2 = %20) -> (i256, i256) { +// CHECK-NEXT: %45 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.trunci %46 : i256 to i8 loc(#loc1) +// CHECK-NEXT: %48 = arith.extui %47 : i8 to i256 loc(#loc1) +// CHECK-NEXT: %49 = arith.cmpi ne, %46, %48 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %49 { +// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%54, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %46 = arith.extui %43 : i8 to i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %46, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %48, %49 : i256, i256 loc(#loc1) +// CHECK-NEXT: %50 = arith.extui %47 : i8 to i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %50, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %52, %53 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = func.call @decode_13(%28) : (i256) -> i8 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.extui %35 : i8 to i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%40, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = func.call @decode_13(%27) : (i256) -> i8 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.extui %39 : i8 to i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %42, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%44, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -312,63 +347,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -377,60 +412,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @array_fixed_34(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @array_fixed_34(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -438,63 +486,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -503,60 +551,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @array_dyn_54(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @array_dyn_54(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -564,63 +625,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -629,60 +690,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @array_fixed_fixed_77(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @array_fixed_fixed_77(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -690,63 +764,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -755,60 +829,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @array_dyn_dyn_98(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @array_dyn_dyn_98(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -816,63 +903,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -881,60 +968,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @array_fixed_dyn_120(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @array_fixed_dyn_120(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -942,63 +1042,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1007,60 +1107,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @array_dyn_fixed_142(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @array_dyn_fixed_142(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1068,63 +1181,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1133,60 +1246,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @string_fixed_163(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @string_fixed_163(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1194,63 +1320,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1259,60 +1385,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @string_dyn_183(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @string_dyn_183(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1320,63 +1459,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1385,60 +1524,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @string_fixed_fixed_206(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @string_fixed_fixed_206(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1446,63 +1598,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1511,60 +1663,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @string_dyn_dyn_227(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @string_dyn_dyn_227(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1572,63 +1737,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1637,60 +1802,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @string_fixed_dyn_249(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @string_fixed_dyn_249(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1698,63 +1876,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1763,60 +1941,73 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @string_dyn_fixed_271(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @string_dyn_fixed_271(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %41, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1830,20 +2021,21 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @string_dyn_fixed_271(%arg0: i256 loc({{.*}}:62:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) @@ -1861,316 +2053,355 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc3) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc3) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc4) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc5) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc5) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc5) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc5) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc5) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c34_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c34_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc5) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc5) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc5) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc5) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) // CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) // CHECK-NEXT: %15 = arith.addi %14, %c64_i256 : i256 loc(#loc5) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %17 = arith.addi %10, %c64_i256 : i256 loc(#loc5) -// CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc5) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc5) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc5) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %19:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { -// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %20 = arith.addi %10, %c64_i256 : i256 loc(#loc5) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %5 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %22:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %23 = arith.addi %10, %21 : i256 loc(#loc5) -// CHECK-NEXT: %24 = arith.addi %23, %c31_i256 : i256 loc(#loc5) -// CHECK-NEXT: %25 = arith.cmpi sge, %24, %5 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %26 = arith.addi %10, %24 : i256 loc(#loc5) +// CHECK-NEXT: %27 = arith.addi %26, %c31_i256 : i256 loc(#loc5) +// CHECK-NEXT: %28 = arith.cmpi sge, %27, %5 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %28 = arith.addi %23, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %29 = arith.muli %27, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %30 = arith.addi %28, %29 : i256 loc(#loc5) -// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %5 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %29 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %31 = arith.addi %26, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %32 = arith.muli %30, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %33 = arith.addi %31, %32 : i256 loc(#loc5) +// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %5 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %32 = arith.muli %27, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %33 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %33 { -// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %35 = arith.muli %30, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %36 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %34 = arith.addi %32, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %37 = arith.addi %36, %34 : i256 loc(#loc5) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %37, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %39 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %27, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %40 = arith.addi %36, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %41 = arith.index_castui %27 : i256 to index loc(#loc5) -// CHECK-NEXT: %42:2 = scf.for %arg4 = %c0 to %41 step %c1 iter_args(%arg5 = %40, %arg6 = %28) -> (i256, i256) { -// CHECK-NEXT: %46 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %48 = arith.cmpi ugt, %47, %c18446744073709551615_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %48 { -// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c43_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %39 = arith.addi %35, %c63_i256 : i256 loc(#loc5) +// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %41 = arith.addi %38, %40 : i256 loc(#loc5) +// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: %43 = arith.cmpi ult, %41, %38 : i256 loc(#loc5) +// CHECK-NEXT: %44 = arith.ori %42, %43 : i1 loc(#loc5) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %41, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %46 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %30, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %47 = arith.addi %38, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %48 = arith.index_castui %30 : i256 to index loc(#loc5) +// CHECK-NEXT: %49:2 = scf.for %arg4 = %c0 to %48 step %c1 iter_args(%arg5 = %47, %arg6 = %31) -> (i256, i256) { +// CHECK-NEXT: %53 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %55 = arith.cmpi ugt, %54, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c43_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) +// CHECK-NEXT: } loc(#loc5) +// CHECK-NEXT: %56 = arith.addi %31, %54 : i256 loc(#loc5) +// CHECK-NEXT: %57 = arith.addi %56, %c31_i256 : i256 loc(#loc5) +// CHECK-NEXT: %58 = arith.cmpi sge, %57, %5 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %58 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c43_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %49 = arith.addi %28, %47 : i256 loc(#loc5) -// CHECK-NEXT: %50 = arith.addi %49, %c31_i256 : i256 loc(#loc5) -// CHECK-NEXT: %51 = arith.cmpi sge, %50, %5 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %51 { -// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c43_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %59 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %60 = llvm.load %59 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %61 = arith.addi %56, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %62 = arith.addi %61, %60 : i256 loc(#loc5) +// CHECK-NEXT: %63 = arith.cmpi ugt, %62, %5 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %63 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc5) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc5) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c39_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc5) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc5) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %52 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %54 = arith.addi %49, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %55 = arith.addi %54, %53 : i256 loc(#loc5) -// CHECK-NEXT: %56 = arith.cmpi ugt, %55, %5 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %56 { -// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc5) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc5) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c39_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc5) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc5) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %64 = arith.addi %60, %c31_i256 : i256 loc(#loc5) +// CHECK-NEXT: %65 = arith.andi %64, %c-32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %66 = arith.cmpi ugt, %60, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.if %66 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %57 = arith.addi %53, %c31_i256 : i256 loc(#loc5) -// CHECK-NEXT: %58 = arith.andi %57, %c-32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %59 = arith.cmpi ugt, %53, %c18446744073709551615_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.if %59 { -// CHECK-NEXT: %74 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %75 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c65_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %76 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intrcall"(%76, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %67 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %69 = arith.addi %65, %c63_i256 : i256 loc(#loc5) +// CHECK-NEXT: %70 = arith.andi %69, %c-32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %71 = arith.addi %68, %70 : i256 loc(#loc5) +// CHECK-NEXT: %72 = arith.cmpi ugt, %71, %c18446744073709551615_i256 : i256 loc(#loc5) +// CHECK-NEXT: %73 = arith.cmpi ult, %71, %68 : i256 loc(#loc5) +// CHECK-NEXT: %74 = arith.ori %72, %73 : i1 loc(#loc5) +// CHECK-NEXT: scf.if %74 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %60 = arith.addi %58, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %61 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %62 = llvm.load %61 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %63 = arith.addi %62, %60 : i256 loc(#loc5) -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %63, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %65 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %53, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %66 = arith.addi %62, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %68 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: "llvm.intr.memmove"(%67, %68, %53) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc5) -// CHECK-NEXT: %69 = arith.addi %66, %53 : i256 loc(#loc5) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %c0_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %71 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %62, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %72 = arith.addi %arg5, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %73 = arith.addi %arg6, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.yield %72, %73 : i256, i256 loc(#loc5) +// CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %71, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %76 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %60, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %77 = arith.addi %68, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %79 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: "llvm.intr.memmove"(%78, %79, %60) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc5) +// CHECK-NEXT: %80 = arith.addi %77, %60 : i256 loc(#loc5) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %c0_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %82 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %68, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %83 = arith.addi %arg5, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %84 = arith.addi %arg6, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %83, %84 : i256, i256 loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %43 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: llvm.store %36, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %44 = arith.addi %arg2, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %45 = arith.addi %arg3, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: scf.yield %44, %45 : i256, i256 loc(#loc5) +// CHECK-NEXT: %50 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: llvm.store %38, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %51 = arith.addi %arg2, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %52 = arith.addi %arg3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: scf.yield %51, %52 : i256, i256 loc(#loc5) // CHECK-NEXT: } loc(#loc5) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc6) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: func.func @string_fixed_dyn_249(%arg0: i256 loc({{.*}}:57:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -2192,62 +2423,62 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc8) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc8) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc9) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc10) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc10) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc10) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc10) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc10) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc10) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc10) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc10) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc10) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc10) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc10) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc10) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc10) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) // CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc10) @@ -2257,250 +2488,289 @@ contract C { // CHECK-NEXT: %17 = arith.addi %15, %16 : i256 loc(#loc10) // CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc10) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc10) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc10) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) // CHECK-NEXT: %19 = arith.muli %14, %c32_i256 : i256 loc(#loc10) // CHECK-NEXT: %20 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc10) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %21 = arith.addi %19, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %24 = arith.addi %23, %21 : i256 loc(#loc10) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %14, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %27 = arith.addi %23, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %28 = arith.index_castui %14 : i256 to index loc(#loc10) -// CHECK-NEXT: %29:2 = scf.for %arg1 = %c0 to %28 step %c1 iter_args(%arg2 = %27, %arg3 = %15) -> (i256, i256) { -// CHECK-NEXT: %30 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.if %32 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc10) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc10) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc10) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %23 = arith.addi %19, %c63_i256 : i256 loc(#loc10) +// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %25 = arith.addi %22, %24 : i256 loc(#loc10) +// CHECK-NEXT: %26 = arith.cmpi ugt, %25, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: %27 = arith.cmpi ult, %25, %22 : i256 loc(#loc10) +// CHECK-NEXT: %28 = arith.ori %26, %27 : i1 loc(#loc10) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %30 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %14, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %31 = arith.addi %22, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %32 = arith.index_castui %14 : i256 to index loc(#loc10) +// CHECK-NEXT: %33:2 = scf.for %arg1 = %c0 to %32 step %c1 iter_args(%arg2 = %31, %arg3 = %15) -> (i256, i256) { +// CHECK-NEXT: %34 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %33 = arith.addi %15, %31 : i256 loc(#loc10) -// CHECK-NEXT: %34 = arith.addi %33, %c31_i256 : i256 loc(#loc10) -// CHECK-NEXT: %35 = arith.cmpi sge, %34, %5 : i256 loc(#loc10) -// CHECK-NEXT: scf.if %35 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc10) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc10) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc10) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %37 = arith.addi %15, %35 : i256 loc(#loc10) +// CHECK-NEXT: %38 = arith.addi %37, %c31_i256 : i256 loc(#loc10) +// CHECK-NEXT: %39 = arith.cmpi sge, %38, %5 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %39 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %38 = arith.addi %37, %c64_i256 : i256 loc(#loc10) -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %40 = arith.addi %33, %c64_i256 : i256 loc(#loc10) -// CHECK-NEXT: %41 = arith.cmpi ugt, %40, %5 : i256 loc(#loc10) -// CHECK-NEXT: scf.if %41 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc10) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc10) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc10) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %42 = arith.addi %41, %c64_i256 : i256 loc(#loc10) +// CHECK-NEXT: %43 = arith.cmpi ugt, %42, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: %44 = arith.cmpi ult, %42, %41 : i256 loc(#loc10) +// CHECK-NEXT: %45 = arith.ori %43, %44 : i1 loc(#loc10) +// CHECK-NEXT: scf.if %45 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %42, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %47 = arith.addi %37, %c64_i256 : i256 loc(#loc10) +// CHECK-NEXT: %48 = arith.cmpi ugt, %47, %5 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %42:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %37, %arg6 = %33) -> (i256, i256) { -// CHECK-NEXT: %46 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %48 = arith.cmpi ugt, %47, %c18446744073709551615_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.if %48 { -// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc10) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c43_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc10) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc10) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %49:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %41, %arg6 = %37) -> (i256, i256) { +// CHECK-NEXT: %53 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %55 = arith.cmpi ugt, %54, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c43_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %49 = arith.addi %33, %47 : i256 loc(#loc10) -// CHECK-NEXT: %50 = arith.addi %49, %c31_i256 : i256 loc(#loc10) -// CHECK-NEXT: %51 = arith.cmpi sge, %50, %5 : i256 loc(#loc10) -// CHECK-NEXT: scf.if %51 { -// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc10) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c43_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc10) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc10) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %56 = arith.addi %37, %54 : i256 loc(#loc10) +// CHECK-NEXT: %57 = arith.addi %56, %c31_i256 : i256 loc(#loc10) +// CHECK-NEXT: %58 = arith.cmpi sge, %57, %5 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %58 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c43_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %52 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %54 = arith.addi %49, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %55 = arith.addi %54, %53 : i256 loc(#loc10) -// CHECK-NEXT: %56 = arith.cmpi ugt, %55, %5 : i256 loc(#loc10) -// CHECK-NEXT: scf.if %56 { -// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc10) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc10) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c39_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc10) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc10) -// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %59 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %60 = llvm.load %59 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %61 = arith.addi %56, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %62 = arith.addi %61, %60 : i256 loc(#loc10) +// CHECK-NEXT: %63 = arith.cmpi ugt, %62, %5 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %63 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc10) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc10) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c39_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc10) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc10) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %57 = arith.addi %53, %c31_i256 : i256 loc(#loc10) -// CHECK-NEXT: %58 = arith.andi %57, %c-32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %59 = arith.cmpi ugt, %53, %c18446744073709551615_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.if %59 { -// CHECK-NEXT: %74 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %75 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c65_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %76 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intrcall"(%76, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %64 = arith.addi %60, %c31_i256 : i256 loc(#loc10) +// CHECK-NEXT: %65 = arith.andi %64, %c-32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %66 = arith.cmpi ugt, %60, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.if %66 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %60 = arith.addi %58, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %61 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %62 = llvm.load %61 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %63 = arith.addi %62, %60 : i256 loc(#loc10) -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %63, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %65 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %53, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %66 = arith.addi %62, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %68 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: "llvm.intr.memmove"(%67, %68, %53) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc10) -// CHECK-NEXT: %69 = arith.addi %66, %53 : i256 loc(#loc10) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c0_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %71 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %62, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %72 = arith.addi %arg5, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %73 = arith.addi %arg6, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.yield %72, %73 : i256, i256 loc(#loc10) +// CHECK-NEXT: %67 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %69 = arith.addi %65, %c63_i256 : i256 loc(#loc10) +// CHECK-NEXT: %70 = arith.andi %69, %c-32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %71 = arith.addi %68, %70 : i256 loc(#loc10) +// CHECK-NEXT: %72 = arith.cmpi ugt, %71, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: %73 = arith.cmpi ult, %71, %68 : i256 loc(#loc10) +// CHECK-NEXT: %74 = arith.ori %72, %73 : i1 loc(#loc10) +// CHECK-NEXT: scf.if %74 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %71, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %76 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %60, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %77 = arith.addi %68, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %79 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intr.memmove"(%78, %79, %60) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: %80 = arith.addi %77, %60 : i256 loc(#loc10) +// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c0_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %82 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %68, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %83 = arith.addi %arg5, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %84 = arith.addi %arg6, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.yield %83, %84 : i256, i256 loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %43 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %37, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %44 = arith.addi %arg2, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %45 = arith.addi %arg3, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.yield %44, %45 : i256, i256 loc(#loc10) +// CHECK-NEXT: %50 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %41, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %51 = arith.addi %arg2, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %52 = arith.addi %arg3, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.yield %51, %52 : i256, i256 loc(#loc10) // CHECK-NEXT: } loc(#loc10) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc11) // CHECK-NEXT: } loc(#loc7) // CHECK-NEXT: func.func @string_dyn_dyn_227(%arg0: i256 loc({{.*}}:52:26)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -2522,62 +2792,62 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc13) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc13) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc14) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc15) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc15) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc15) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc15) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc15) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc15) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc15) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc15) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc15) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc15) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc15) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc15) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc15) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) // CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc15) @@ -2587,268 +2857,304 @@ contract C { // CHECK-NEXT: %17 = arith.addi %15, %16 : i256 loc(#loc15) // CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc15) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc15) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc15) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) // CHECK-NEXT: %19 = arith.muli %14, %c32_i256 : i256 loc(#loc15) // CHECK-NEXT: %20 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc15) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %21 = arith.addi %19, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %24 = arith.addi %23, %21 : i256 loc(#loc15) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %14, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %27 = arith.addi %23, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %28 = arith.index_castui %14 : i256 to index loc(#loc15) -// CHECK-NEXT: %29:2 = scf.for %arg1 = %c0 to %28 step %c1 iter_args(%arg2 = %27, %arg3 = %15) -> (i256, i256) { -// CHECK-NEXT: %30 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %32 { -// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc15) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc15) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %23 = arith.addi %19, %c63_i256 : i256 loc(#loc15) +// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %25 = arith.addi %22, %24 : i256 loc(#loc15) +// CHECK-NEXT: %26 = arith.cmpi ugt, %25, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: %27 = arith.cmpi ult, %25, %22 : i256 loc(#loc15) +// CHECK-NEXT: %28 = arith.ori %26, %27 : i1 loc(#loc15) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %30 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %14, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %31 = arith.addi %22, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %32 = arith.index_castui %14 : i256 to index loc(#loc15) +// CHECK-NEXT: %33:2 = scf.for %arg1 = %c0 to %32 step %c1 iter_args(%arg2 = %31, %arg3 = %15) -> (i256, i256) { +// CHECK-NEXT: %34 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) // CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %33 = arith.addi %15, %31 : i256 loc(#loc15) -// CHECK-NEXT: %34 = arith.addi %33, %c31_i256 : i256 loc(#loc15) -// CHECK-NEXT: %35 = arith.cmpi sge, %34, %5 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %35 { -// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc15) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc15) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %37 = arith.addi %15, %35 : i256 loc(#loc15) +// CHECK-NEXT: %38 = arith.addi %37, %c31_i256 : i256 loc(#loc15) +// CHECK-NEXT: %39 = arith.cmpi sge, %38, %5 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %39 { +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) // CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %36 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %38 = arith.addi %33, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %39 = arith.muli %37, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %40 = arith.addi %38, %39 : i256 loc(#loc15) -// CHECK-NEXT: %41 = arith.cmpi ugt, %40, %5 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %41 { -// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc15) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc15) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %40 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %42 = arith.addi %37, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %43 = arith.muli %41, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %44 = arith.addi %42, %43 : i256 loc(#loc15) +// CHECK-NEXT: %45 = arith.cmpi ugt, %44, %5 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %45 { +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) // CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %42 = arith.muli %37, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %43 = arith.cmpi ugt, %37, %c18446744073709551615_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %43 { -// CHECK-NEXT: %56 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %57 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c65_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%58, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %46 = arith.muli %41, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %47 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %47 { +// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %65 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %66 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%66, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %44 = arith.addi %42, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %47 = arith.addi %46, %44 : i256 loc(#loc15) // CHECK-NEXT: %48 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %47, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %49 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %37, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %50 = arith.addi %46, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %51 = arith.index_castui %37 : i256 to index loc(#loc15) -// CHECK-NEXT: %52:2 = scf.for %arg4 = %c0 to %51 step %c1 iter_args(%arg5 = %50, %arg6 = %38) -> (i256, i256) { -// CHECK-NEXT: %56 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %58 = arith.cmpi ugt, %57, %c18446744073709551615_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %58 { -// CHECK-NEXT: %84 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %85 = llvm.load %84 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %86 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %87 = arith.addi %85, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %88 = llvm.inttoptr %87 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %88 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %89 = arith.addi %85, %c36_i256 : i256 loc(#loc15) -// CHECK-NEXT: %90 = llvm.inttoptr %89 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c43_i256, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %91 = arith.addi %85, %c68_i256 : i256 loc(#loc15) -// CHECK-NEXT: %92 = llvm.inttoptr %91 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %92 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %93 = arith.addi %85, %c100_i256 : i256 loc(#loc15) -// CHECK-NEXT: %94 = llvm.inttoptr %93 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %94 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %95 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%95, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %50 = arith.addi %46, %c63_i256 : i256 loc(#loc15) +// CHECK-NEXT: %51 = arith.andi %50, %c-32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %52 = arith.addi %49, %51 : i256 loc(#loc15) +// CHECK-NEXT: %53 = arith.cmpi ugt, %52, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: %54 = arith.cmpi ult, %52, %49 : i256 loc(#loc15) +// CHECK-NEXT: %55 = arith.ori %53, %54 : i1 loc(#loc15) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %65 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %66 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%66, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %52, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %57 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %41, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %58 = arith.addi %49, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %59 = arith.index_castui %41 : i256 to index loc(#loc15) +// CHECK-NEXT: %60:2 = scf.for %arg4 = %c0 to %59 step %c1 iter_args(%arg5 = %58, %arg6 = %42) -> (i256, i256) { +// CHECK-NEXT: %64 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %66 = arith.cmpi ugt, %65, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %66 { +// CHECK-NEXT: %96 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %97 = llvm.load %96 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %98 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %98 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %99 = arith.addi %97, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %100 = llvm.inttoptr %99 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %100 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %101 = arith.addi %97, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %102 = llvm.inttoptr %101 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c43_i256, %102 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %103 = arith.addi %97, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %104 = llvm.inttoptr %103 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %104 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %105 = arith.addi %97, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %106 = llvm.inttoptr %105 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %106 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %107 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%107, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %59 = arith.addi %38, %57 : i256 loc(#loc15) -// CHECK-NEXT: %60 = arith.addi %59, %c31_i256 : i256 loc(#loc15) -// CHECK-NEXT: %61 = arith.cmpi sge, %60, %5 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %61 { -// CHECK-NEXT: %84 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %85 = llvm.load %84 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %86 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %87 = arith.addi %85, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %88 = llvm.inttoptr %87 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %88 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %89 = arith.addi %85, %c36_i256 : i256 loc(#loc15) -// CHECK-NEXT: %90 = llvm.inttoptr %89 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c43_i256, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %91 = arith.addi %85, %c68_i256 : i256 loc(#loc15) -// CHECK-NEXT: %92 = llvm.inttoptr %91 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %92 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %93 = arith.addi %85, %c100_i256 : i256 loc(#loc15) -// CHECK-NEXT: %94 = llvm.inttoptr %93 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %94 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %95 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%95, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %67 = arith.addi %42, %65 : i256 loc(#loc15) +// CHECK-NEXT: %68 = arith.addi %67, %c31_i256 : i256 loc(#loc15) +// CHECK-NEXT: %69 = arith.cmpi sge, %68, %5 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %69 { +// CHECK-NEXT: %96 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %97 = llvm.load %96 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %98 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %98 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %99 = arith.addi %97, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %100 = llvm.inttoptr %99 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %100 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %101 = arith.addi %97, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %102 = llvm.inttoptr %101 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c43_i256, %102 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %103 = arith.addi %97, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %104 = llvm.inttoptr %103 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %104 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %105 = arith.addi %97, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %106 = llvm.inttoptr %105 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %106 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %107 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%107, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %62 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %63 = llvm.load %62 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %64 = arith.addi %59, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %65 = arith.addi %64, %63 : i256 loc(#loc15) -// CHECK-NEXT: %66 = arith.cmpi ugt, %65, %5 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %66 { -// CHECK-NEXT: %84 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %85 = llvm.load %84 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %86 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %87 = arith.addi %85, %c4_i256 : i256 loc(#loc15) -// CHECK-NEXT: %88 = llvm.inttoptr %87 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c32_i256, %88 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %89 = arith.addi %85, %c36_i256 : i256 loc(#loc15) -// CHECK-NEXT: %90 = llvm.inttoptr %89 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c39_i256, %90 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %91 = arith.addi %85, %c68_i256 : i256 loc(#loc15) -// CHECK-NEXT: %92 = llvm.inttoptr %91 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %92 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %93 = arith.addi %85, %c100_i256 : i256 loc(#loc15) -// CHECK-NEXT: %94 = llvm.inttoptr %93 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %94 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %95 = llvm.inttoptr %85 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%95, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %70 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %71 = llvm.load %70 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %72 = arith.addi %67, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %73 = arith.addi %72, %71 : i256 loc(#loc15) +// CHECK-NEXT: %74 = arith.cmpi ugt, %73, %5 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %74 { +// CHECK-NEXT: %96 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %97 = llvm.load %96 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %98 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %98 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %99 = arith.addi %97, %c4_i256 : i256 loc(#loc15) +// CHECK-NEXT: %100 = llvm.inttoptr %99 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c32_i256, %100 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %101 = arith.addi %97, %c36_i256 : i256 loc(#loc15) +// CHECK-NEXT: %102 = llvm.inttoptr %101 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c39_i256, %102 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %103 = arith.addi %97, %c68_i256 : i256 loc(#loc15) +// CHECK-NEXT: %104 = llvm.inttoptr %103 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %104 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %105 = arith.addi %97, %c100_i256 : i256 loc(#loc15) +// CHECK-NEXT: %106 = llvm.inttoptr %105 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %106 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %107 = llvm.inttoptr %97 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%107, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %67 = arith.addi %63, %c31_i256 : i256 loc(#loc15) -// CHECK-NEXT: %68 = arith.andi %67, %c-32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %69 = arith.cmpi ugt, %63, %c18446744073709551615_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %69 { -// CHECK-NEXT: %84 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %85 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c65_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %86 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%86, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %75 = arith.addi %71, %c31_i256 : i256 loc(#loc15) +// CHECK-NEXT: %76 = arith.andi %75, %c-32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %77 = arith.cmpi ugt, %71, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %77 { +// CHECK-NEXT: %96 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %96 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %97 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %98 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%98, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %78 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %79 = llvm.load %78 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %80 = arith.addi %76, %c63_i256 : i256 loc(#loc15) +// CHECK-NEXT: %81 = arith.andi %80, %c-32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %82 = arith.addi %79, %81 : i256 loc(#loc15) +// CHECK-NEXT: %83 = arith.cmpi ugt, %82, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: %84 = arith.cmpi ult, %82, %79 : i256 loc(#loc15) +// CHECK-NEXT: %85 = arith.ori %83, %84 : i1 loc(#loc15) +// CHECK-NEXT: scf.if %85 { +// CHECK-NEXT: %96 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %96 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %97 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %98 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%98, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %70 = arith.addi %68, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %71 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %72 = llvm.load %71 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %73 = arith.addi %72, %70 : i256 loc(#loc15) -// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %73, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %75 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %63, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %76 = arith.addi %72, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %78 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intr.memmove"(%77, %78, %63) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc15) -// CHECK-NEXT: %79 = arith.addi %76, %63 : i256 loc(#loc15) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %c0_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %81 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %72, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %82 = arith.addi %arg5, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %83 = arith.addi %arg6, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.yield %82, %83 : i256, i256 loc(#loc15) +// CHECK-NEXT: %86 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %82, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %87 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %71, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %88 = arith.addi %79, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %90 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intr.memmove"(%89, %90, %71) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %91 = arith.addi %88, %71 : i256 loc(#loc15) +// CHECK-NEXT: %92 = llvm.inttoptr %91 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c0_i256, %92 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %93 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %79, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %94 = arith.addi %arg5, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %95 = arith.addi %arg6, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.yield %94, %95 : i256, i256 loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %53 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %46, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %54 = arith.addi %arg2, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %55 = arith.addi %arg3, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.yield %54, %55 : i256, i256 loc(#loc15) +// CHECK-NEXT: %61 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %49, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %62 = arith.addi %arg2, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %63 = arith.addi %arg3, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.yield %62, %63 : i256, i256 loc(#loc15) // CHECK-NEXT: } loc(#loc15) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc16) // CHECK-NEXT: } loc(#loc12) // CHECK-NEXT: func.func @string_fixed_fixed_206(%arg0: i256 loc({{.*}}:47:30)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) @@ -2856,6 +3162,10 @@ contract C { // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) @@ -2873,295 +3183,333 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc18) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc18) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc19) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc20) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc20) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc20) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc20) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc20) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c34_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc20) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc20) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc20) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c34_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc20) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc20) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc20) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc20) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc20) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc20) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc20) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) // CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) // CHECK-NEXT: %15 = arith.addi %14, %c64_i256 : i256 loc(#loc20) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %17 = arith.addi %10, %c64_i256 : i256 loc(#loc20) -// CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc20) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc20) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc20) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc20) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc20) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %20 = arith.addi %10, %c64_i256 : i256 loc(#loc20) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %5 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc20) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %19:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { -// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %39 = arith.addi %37, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %41 = arith.addi %37, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c43_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %43 = arith.addi %37, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %22:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) // CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %45 = arith.addi %37, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc20) // CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %47 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%47, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %23 = arith.addi %10, %21 : i256 loc(#loc20) -// CHECK-NEXT: %24 = arith.addi %23, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: %25 = arith.cmpi sge, %24, %5 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %39 = arith.addi %37, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %41 = arith.addi %37, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c43_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %43 = arith.addi %37, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %26 = arith.addi %10, %24 : i256 loc(#loc20) +// CHECK-NEXT: %27 = arith.addi %26, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %28 = arith.cmpi sge, %27, %5 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) // CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %45 = arith.addi %37, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc20) // CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %47 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%47, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %28 = arith.addi %27, %c64_i256 : i256 loc(#loc20) // CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %30 = arith.addi %23, %c64_i256 : i256 loc(#loc20) -// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %5 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %39 = arith.addi %37, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %41 = arith.addi %37, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c43_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %43 = arith.addi %37, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %31 = arith.addi %30, %c64_i256 : i256 loc(#loc20) +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %30 : i256 loc(#loc20) +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 loc(#loc20) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %36 = arith.addi %26, %c64_i256 : i256 loc(#loc20) +// CHECK-NEXT: %37 = arith.cmpi ugt, %36, %5 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %37 { +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) // CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %45 = arith.addi %37, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc20) // CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %47 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%47, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %32:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %27, %arg6 = %23) -> (i256, i256) { -// CHECK-NEXT: %36 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %38 = arith.cmpi ugt, %37, %c18446744073709551615_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %38 { -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc20) -// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc20) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %38:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %30, %arg6 = %26) -> (i256, i256) { +// CHECK-NEXT: %42 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %44 = arith.cmpi ugt, %43, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc20) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c43_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %39 = arith.addi %23, %37 : i256 loc(#loc20) -// CHECK-NEXT: %40 = arith.addi %39, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: %41 = arith.cmpi sge, %40, %5 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %41 { -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc20) -// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc20) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %45 = arith.addi %26, %43 : i256 loc(#loc20) +// CHECK-NEXT: %46 = arith.addi %45, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %47 = arith.cmpi sge, %46, %5 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %47 { +// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc20) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c43_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %42 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %44 = arith.addi %39, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %45 = arith.addi %44, %43 : i256 loc(#loc20) -// CHECK-NEXT: %46 = arith.cmpi ugt, %45, %5 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %46 { -// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc20) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc20) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c39_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc20) -// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc20) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %48 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %50 = arith.addi %45, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %51 = arith.addi %50, %49 : i256 loc(#loc20) +// CHECK-NEXT: %52 = arith.cmpi ugt, %51, %5 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %52 { +// CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %77 = arith.addi %75, %c4_i256 : i256 loc(#loc20) +// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c32_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %79 = arith.addi %75, %c36_i256 : i256 loc(#loc20) +// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c39_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %81 = arith.addi %75, %c68_i256 : i256 loc(#loc20) +// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %83 = arith.addi %75, %c100_i256 : i256 loc(#loc20) +// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%85, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %47 = arith.addi %43, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: %48 = arith.andi %47, %c-32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %49 = arith.cmpi ugt, %43, %c18446744073709551615_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %49 { -// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %65 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c65_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %66 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%66, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %53 = arith.addi %49, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %54 = arith.andi %53, %c-32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %55 = arith.cmpi ugt, %49, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %74 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %75 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c65_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %76 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%76, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %50 = arith.addi %48, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %53 = arith.addi %52, %50 : i256 loc(#loc20) -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %53, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %55 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %43, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %56 = arith.addi %52, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %58 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intr.memmove"(%57, %58, %43) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc20) -// CHECK-NEXT: %59 = arith.addi %56, %43 : i256 loc(#loc20) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c0_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %61 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %52, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %62 = arith.addi %arg5, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %63 = arith.addi %arg6, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.yield %62, %63 : i256, i256 loc(#loc20) +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %58 = arith.addi %54, %c63_i256 : i256 loc(#loc20) +// CHECK-NEXT: %59 = arith.andi %58, %c-32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %60 = arith.addi %57, %59 : i256 loc(#loc20) +// CHECK-NEXT: %61 = arith.cmpi ugt, %60, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: %62 = arith.cmpi ult, %60, %57 : i256 loc(#loc20) +// CHECK-NEXT: %63 = arith.ori %61, %62 : i1 loc(#loc20) +// CHECK-NEXT: scf.if %63 { +// CHECK-NEXT: %74 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %75 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c65_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %76 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%76, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %60, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %65 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %49, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %66 = arith.addi %57, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %67 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %68 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intr.memmove"(%67, %68, %49) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %69 = arith.addi %66, %49 : i256 loc(#loc20) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c0_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %71 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %57, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %72 = arith.addi %arg5, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %73 = arith.addi %arg6, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.yield %72, %73 : i256, i256 loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %33 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %27, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %34 = arith.addi %arg2, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %35 = arith.addi %arg3, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.yield %34, %35 : i256, i256 loc(#loc20) +// CHECK-NEXT: %39 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %30, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %40 = arith.addi %arg2, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %41 = arith.addi %arg3, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.yield %40, %41 : i256, i256 loc(#loc20) // CHECK-NEXT: } loc(#loc20) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc21) // CHECK-NEXT: } loc(#loc17) // CHECK-NEXT: func.func @string_dyn_183(%arg0: i256 loc({{.*}}:42:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -3183,62 +3531,62 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc23) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc23) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc24) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc25) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc25) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc25) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc25) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc25) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc25) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc25) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc25) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc25) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc25) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc25) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc25) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc25) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc25) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc25) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc25) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc25) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) // CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc25) @@ -3248,165 +3596,188 @@ contract C { // CHECK-NEXT: %17 = arith.addi %15, %16 : i256 loc(#loc25) // CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc25) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc25) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc25) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc25) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc25) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) // CHECK-NEXT: %19 = arith.muli %14, %c32_i256 : i256 loc(#loc25) // CHECK-NEXT: %20 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc25) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) +// CHECK-NEXT: %23 = arith.addi %19, %c63_i256 : i256 loc(#loc25) +// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %25 = arith.addi %22, %24 : i256 loc(#loc25) +// CHECK-NEXT: %26 = arith.cmpi ugt, %25, %c18446744073709551615_i256 : i256 loc(#loc25) +// CHECK-NEXT: %27 = arith.cmpi ult, %25, %22 : i256 loc(#loc25) +// CHECK-NEXT: %28 = arith.ori %26, %27 : i1 loc(#loc25) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) -// CHECK-NEXT: %21 = arith.addi %19, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %24 = arith.addi %23, %21 : i256 loc(#loc25) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %14, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %27 = arith.addi %23, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %28 = arith.index_castui %14 : i256 to index loc(#loc25) -// CHECK-NEXT: %29:2 = scf.for %arg1 = %c0 to %28 step %c1 iter_args(%arg2 = %27, %arg3 = %15) -> (i256, i256) { -// CHECK-NEXT: %30 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc25) -// CHECK-NEXT: scf.if %32 { -// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc25) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc25) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc25) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %30 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %14, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %31 = arith.addi %22, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %32 = arith.index_castui %14 : i256 to index loc(#loc25) +// CHECK-NEXT: %33:2 = scf.for %arg1 = %c0 to %32 step %c1 iter_args(%arg2 = %31, %arg3 = %15) -> (i256, i256) { +// CHECK-NEXT: %34 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) +// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %c18446744073709551615_i256 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) // CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %69 = arith.addi %67, %c4_i256 : i256 loc(#loc25) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c32_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %71 = arith.addi %67, %c36_i256 : i256 loc(#loc25) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c43_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %73 = arith.addi %67, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %75 = arith.addi %67, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %77 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%77, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) -// CHECK-NEXT: %33 = arith.addi %15, %31 : i256 loc(#loc25) -// CHECK-NEXT: %34 = arith.addi %33, %c31_i256 : i256 loc(#loc25) -// CHECK-NEXT: %35 = arith.cmpi sge, %34, %5 : i256 loc(#loc25) -// CHECK-NEXT: scf.if %35 { -// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc25) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc25) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc25) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %37 = arith.addi %15, %35 : i256 loc(#loc25) +// CHECK-NEXT: %38 = arith.addi %37, %c31_i256 : i256 loc(#loc25) +// CHECK-NEXT: %39 = arith.cmpi sge, %38, %5 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %39 { +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) // CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %69 = arith.addi %67, %c4_i256 : i256 loc(#loc25) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c32_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %71 = arith.addi %67, %c36_i256 : i256 loc(#loc25) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c43_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %73 = arith.addi %67, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %75 = arith.addi %67, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %77 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%77, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) -// CHECK-NEXT: %36 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %38 = arith.addi %33, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %39 = arith.addi %38, %37 : i256 loc(#loc25) -// CHECK-NEXT: %40 = arith.cmpi ugt, %39, %5 : i256 loc(#loc25) -// CHECK-NEXT: scf.if %40 { -// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc25) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc25) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c39_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc25) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %40 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) +// CHECK-NEXT: %42 = arith.addi %37, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %43 = arith.addi %42, %41 : i256 loc(#loc25) +// CHECK-NEXT: %44 = arith.cmpi ugt, %43, %5 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %66 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %67 = llvm.load %66 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) // CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %69 = arith.addi %67, %c4_i256 : i256 loc(#loc25) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c32_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %71 = arith.addi %67, %c36_i256 : i256 loc(#loc25) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c39_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %73 = arith.addi %67, %c68_i256 : i256 loc(#loc25) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %75 = arith.addi %67, %c100_i256 : i256 loc(#loc25) +// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %77 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%77, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) -// CHECK-NEXT: %41 = arith.addi %37, %c31_i256 : i256 loc(#loc25) -// CHECK-NEXT: %42 = arith.andi %41, %c-32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %43 = arith.cmpi ugt, %37, %c18446744073709551615_i256 : i256 loc(#loc25) -// CHECK-NEXT: scf.if %43 { -// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: %45 = arith.addi %41, %c31_i256 : i256 loc(#loc25) +// CHECK-NEXT: %46 = arith.andi %45, %c-32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %47 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %47 { +// CHECK-NEXT: %66 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %67 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c65_i256, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %68 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%68, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) // CHECK-NEXT: } loc(#loc25) -// CHECK-NEXT: %44 = arith.addi %42, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %47 = arith.addi %46, %44 : i256 loc(#loc25) // CHECK-NEXT: %48 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %47, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %49 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %37, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %50 = arith.addi %46, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %52 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: "llvm.intr.memmove"(%51, %52, %37) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc25) -// CHECK-NEXT: %53 = arith.addi %50, %37 : i256 loc(#loc25) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %c0_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %55 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %46, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %56 = arith.addi %arg2, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %57 = arith.addi %arg3, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: scf.yield %56, %57 : i256, i256 loc(#loc25) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) +// CHECK-NEXT: %50 = arith.addi %46, %c63_i256 : i256 loc(#loc25) +// CHECK-NEXT: %51 = arith.andi %50, %c-32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %52 = arith.addi %49, %51 : i256 loc(#loc25) +// CHECK-NEXT: %53 = arith.cmpi ugt, %52, %c18446744073709551615_i256 : i256 loc(#loc25) +// CHECK-NEXT: %54 = arith.cmpi ult, %52, %49 : i256 loc(#loc25) +// CHECK-NEXT: %55 = arith.ori %53, %54 : i1 loc(#loc25) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %66 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %67 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c65_i256, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %68 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%68, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %52, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %57 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %41, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %58 = arith.addi %49, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %60 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intr.memmove"(%59, %60, %41) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: %61 = arith.addi %58, %41 : i256 loc(#loc25) +// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %c0_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %63 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: llvm.store %49, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: %64 = arith.addi %arg2, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %65 = arith.addi %arg3, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: scf.yield %64, %65 : i256, i256 loc(#loc25) // CHECK-NEXT: } loc(#loc25) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc26) // CHECK-NEXT: } loc(#loc22) // CHECK-NEXT: func.func @string_fixed_163(%arg0: i256 loc({{.*}}:37:24)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) @@ -3414,6 +3785,10 @@ contract C { // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) @@ -3431,213 +3806,240 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc28) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc28) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc29) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc30) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc30) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc30) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc30) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) // CHECK-NEXT: } loc(#loc30) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc30) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc30) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc30) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc30) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c34_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc30) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc30) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc30) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc30) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c34_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc30) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc30) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) // CHECK-NEXT: } loc(#loc30) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc30) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc30) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc30) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc30) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc30) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc30) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc30) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc30) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc30) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc30) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc30) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc30) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) // CHECK-NEXT: } loc(#loc30) // CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) // CHECK-NEXT: %15 = arith.addi %14, %c64_i256 : i256 loc(#loc30) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %17 = arith.addi %10, %c64_i256 : i256 loc(#loc30) -// CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc30) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc30) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc30) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc30) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc30) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc30) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc30) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc30) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) // CHECK-NEXT: } loc(#loc30) -// CHECK-NEXT: %19:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { -// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc30) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %48 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %51 = arith.addi %49, %c4_i256 : i256 loc(#loc30) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c32_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %53 = arith.addi %49, %c36_i256 : i256 loc(#loc30) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c43_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %55 = arith.addi %49, %c68_i256 : i256 loc(#loc30) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %57 = arith.addi %49, %c100_i256 : i256 loc(#loc30) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %59 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%59, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) -// CHECK-NEXT: } loc(#loc30) -// CHECK-NEXT: %23 = arith.addi %10, %21 : i256 loc(#loc30) -// CHECK-NEXT: %24 = arith.addi %23, %c31_i256 : i256 loc(#loc30) -// CHECK-NEXT: %25 = arith.cmpi sge, %24, %5 : i256 loc(#loc30) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %20 = arith.addi %10, %c64_i256 : i256 loc(#loc30) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %5 : i256 loc(#loc30) +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc30) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc30) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc30) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc30) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) +// CHECK-NEXT: } loc(#loc30) +// CHECK-NEXT: %22:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %c18446744073709551615_i256 : i256 loc(#loc30) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %48 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %51 = arith.addi %49, %c4_i256 : i256 loc(#loc30) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c32_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %53 = arith.addi %49, %c36_i256 : i256 loc(#loc30) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c43_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %55 = arith.addi %49, %c68_i256 : i256 loc(#loc30) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %57 = arith.addi %49, %c100_i256 : i256 loc(#loc30) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %59 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%59, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %58 = arith.addi %56, %c4_i256 : i256 loc(#loc30) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c32_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %60 = arith.addi %56, %c36_i256 : i256 loc(#loc30) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c43_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %62 = arith.addi %56, %c68_i256 : i256 loc(#loc30) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %64 = arith.addi %56, %c100_i256 : i256 loc(#loc30) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %66 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%66, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) // CHECK-NEXT: } loc(#loc30) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %28 = arith.addi %23, %c32_i256 : i256 loc(#loc30) -// CHECK-NEXT: %29 = arith.addi %28, %27 : i256 loc(#loc30) -// CHECK-NEXT: %30 = arith.cmpi ugt, %29, %5 : i256 loc(#loc30) -// CHECK-NEXT: scf.if %30 { -// CHECK-NEXT: %48 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %51 = arith.addi %49, %c4_i256 : i256 loc(#loc30) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c32_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %53 = arith.addi %49, %c36_i256 : i256 loc(#loc30) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c39_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %55 = arith.addi %49, %c68_i256 : i256 loc(#loc30) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %57 = arith.addi %49, %c100_i256 : i256 loc(#loc30) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %59 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%59, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %26 = arith.addi %10, %24 : i256 loc(#loc30) +// CHECK-NEXT: %27 = arith.addi %26, %c31_i256 : i256 loc(#loc30) +// CHECK-NEXT: %28 = arith.cmpi sge, %27, %5 : i256 loc(#loc30) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %58 = arith.addi %56, %c4_i256 : i256 loc(#loc30) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c32_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %60 = arith.addi %56, %c36_i256 : i256 loc(#loc30) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c43_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %62 = arith.addi %56, %c68_i256 : i256 loc(#loc30) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %64 = arith.addi %56, %c100_i256 : i256 loc(#loc30) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %66 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%66, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) // CHECK-NEXT: } loc(#loc30) -// CHECK-NEXT: %31 = arith.addi %27, %c31_i256 : i256 loc(#loc30) -// CHECK-NEXT: %32 = arith.andi %31, %c-32_i256 : i256 loc(#loc30) -// CHECK-NEXT: %33 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc30) +// CHECK-NEXT: %29 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %31 = arith.addi %26, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %32 = arith.addi %31, %30 : i256 loc(#loc30) +// CHECK-NEXT: %33 = arith.cmpi ugt, %32, %5 : i256 loc(#loc30) // CHECK-NEXT: scf.if %33 { -// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %49 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c65_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %50 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intrcall"(%50, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %58 = arith.addi %56, %c4_i256 : i256 loc(#loc30) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c32_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %60 = arith.addi %56, %c36_i256 : i256 loc(#loc30) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c39_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %62 = arith.addi %56, %c68_i256 : i256 loc(#loc30) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %64 = arith.addi %56, %c100_i256 : i256 loc(#loc30) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %66 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%66, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) // CHECK-NEXT: } loc(#loc30) -// CHECK-NEXT: %34 = arith.addi %32, %c32_i256 : i256 loc(#loc30) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) -// CHECK-NEXT: %37 = arith.addi %36, %34 : i256 loc(#loc30) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %37, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %39 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %27, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %40 = arith.addi %36, %c32_i256 : i256 loc(#loc30) -// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %42 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: "llvm.intr.memmove"(%41, %42, %27) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc30) -// CHECK-NEXT: %43 = arith.addi %40, %27 : i256 loc(#loc30) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %c0_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %45 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: llvm.store %36, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) -// CHECK-NEXT: %46 = arith.addi %arg2, %c32_i256 : i256 loc(#loc30) -// CHECK-NEXT: %47 = arith.addi %arg3, %c32_i256 : i256 loc(#loc30) -// CHECK-NEXT: scf.yield %46, %47 : i256, i256 loc(#loc30) +// CHECK-NEXT: %34 = arith.addi %30, %c31_i256 : i256 loc(#loc30) +// CHECK-NEXT: %35 = arith.andi %34, %c-32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %36 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc30) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %56 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c65_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %57 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%57, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) +// CHECK-NEXT: } loc(#loc30) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc30) +// CHECK-NEXT: %39 = arith.addi %35, %c63_i256 : i256 loc(#loc30) +// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %41 = arith.addi %38, %40 : i256 loc(#loc30) +// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc30) +// CHECK-NEXT: %43 = arith.cmpi ult, %41, %38 : i256 loc(#loc30) +// CHECK-NEXT: %44 = arith.ori %42, %43 : i1 loc(#loc30) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %56 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c65_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %57 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intrcall"(%57, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc30) +// CHECK-NEXT: } loc(#loc30) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %41, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %46 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %30, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %47 = arith.addi %38, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %49 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: "llvm.intr.memmove"(%48, %49, %30) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc30) +// CHECK-NEXT: %50 = arith.addi %47, %30 : i256 loc(#loc30) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %c0_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %52 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: llvm.store %38, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc30) +// CHECK-NEXT: %53 = arith.addi %arg2, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: %54 = arith.addi %arg3, %c32_i256 : i256 loc(#loc30) +// CHECK-NEXT: scf.yield %53, %54 : i256, i256 loc(#loc30) // CHECK-NEXT: } loc(#loc30) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc31) // CHECK-NEXT: } loc(#loc27) // CHECK-NEXT: func.func @array_dyn_fixed_142(%arg0: i256 loc({{.*}}:32:27)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) @@ -3655,213 +4057,240 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc33) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc33) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc34) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc35) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc35) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc35) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc35) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc35) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc35) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc35) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c34_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc35) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc35) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc35) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc35) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c34_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc35) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc35) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc35) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc35) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc35) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc35) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc35) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc35) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc35) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc35) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc35) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc35) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc35) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc35) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) // CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) // CHECK-NEXT: %15 = arith.addi %14, %c64_i256 : i256 loc(#loc35) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %17 = arith.addi %10, %c64_i256 : i256 loc(#loc35) -// CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc35) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc35) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc35) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc35) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %23 = arith.addi %21, %c4_i256 : i256 loc(#loc35) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c32_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %25 = arith.addi %21, %c36_i256 : i256 loc(#loc35) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c43_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %27 = arith.addi %21, %c68_i256 : i256 loc(#loc35) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %29 = arith.addi %21, %c100_i256 : i256 loc(#loc35) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %31 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%31, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) +// CHECK-NEXT: } loc(#loc35) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %20 = arith.addi %10, %c64_i256 : i256 loc(#loc35) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %5 : i256 loc(#loc35) +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %26 = arith.addi %24, %c4_i256 : i256 loc(#loc35) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c32_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %28 = arith.addi %24, %c36_i256 : i256 loc(#loc35) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c43_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %30 = arith.addi %24, %c68_i256 : i256 loc(#loc35) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %32 = arith.addi %24, %c100_i256 : i256 loc(#loc35) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %34 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%34, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %19:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { -// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc35) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc35) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc35) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc35) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc35) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %22:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %14, %arg3 = %10) -> (i256, i256) { +// CHECK-NEXT: %23 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %c18446744073709551615_i256 : i256 loc(#loc35) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc35) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc35) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc35) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc35) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %23 = arith.addi %10, %21 : i256 loc(#loc35) -// CHECK-NEXT: %24 = arith.addi %23, %c31_i256 : i256 loc(#loc35) -// CHECK-NEXT: %25 = arith.cmpi sge, %24, %5 : i256 loc(#loc35) -// CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc35) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc35) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc35) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc35) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %26 = arith.addi %10, %24 : i256 loc(#loc35) +// CHECK-NEXT: %27 = arith.addi %26, %c31_i256 : i256 loc(#loc35) +// CHECK-NEXT: %28 = arith.cmpi sge, %27, %5 : i256 loc(#loc35) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc35) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc35) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc35) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc35) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %28 = arith.addi %23, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %29 = arith.muli %27, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %30 = arith.addi %28, %29 : i256 loc(#loc35) -// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %5 : i256 loc(#loc35) -// CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %46 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %49 = arith.addi %47, %c4_i256 : i256 loc(#loc35) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c32_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %51 = arith.addi %47, %c36_i256 : i256 loc(#loc35) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c43_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %53 = arith.addi %47, %c68_i256 : i256 loc(#loc35) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %55 = arith.addi %47, %c100_i256 : i256 loc(#loc35) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %57 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%57, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %29 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %31 = arith.addi %26, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %32 = arith.muli %30, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %33 = arith.addi %31, %32 : i256 loc(#loc35) +// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %5 : i256 loc(#loc35) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %53 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %56 = arith.addi %54, %c4_i256 : i256 loc(#loc35) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c32_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %58 = arith.addi %54, %c36_i256 : i256 loc(#loc35) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c43_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %60 = arith.addi %54, %c68_i256 : i256 loc(#loc35) +// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %62 = arith.addi %54, %c100_i256 : i256 loc(#loc35) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %64 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%64, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %32 = arith.muli %27, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %33 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc35) -// CHECK-NEXT: scf.if %33 { -// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %35 = arith.muli %30, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %36 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc35) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %34 = arith.addi %32, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %37 = arith.addi %36, %34 : i256 loc(#loc35) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %37, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %39 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %27, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %40 = arith.addi %36, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %41 = arith.index_castui %27 : i256 to index loc(#loc35) -// CHECK-NEXT: %42:2 = scf.for %arg4 = %c0 to %41 step %c1 iter_args(%arg5 = %40, %arg6 = %28) -> (i256, i256) { -// CHECK-NEXT: %46 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %48 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %47, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %49 = arith.addi %arg5, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %50 = arith.addi %arg6, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: scf.yield %49, %50 : i256, i256 loc(#loc35) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %39 = arith.addi %35, %c63_i256 : i256 loc(#loc35) +// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %41 = arith.addi %38, %40 : i256 loc(#loc35) +// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc35) +// CHECK-NEXT: %43 = arith.cmpi ult, %41, %38 : i256 loc(#loc35) +// CHECK-NEXT: %44 = arith.ori %42, %43 : i1 loc(#loc35) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) +// CHECK-NEXT: } loc(#loc35) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %41, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %46 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %30, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %47 = arith.addi %38, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %48 = arith.index_castui %30 : i256 to index loc(#loc35) +// CHECK-NEXT: %49:2 = scf.for %arg4 = %c0 to %48 step %c1 iter_args(%arg5 = %47, %arg6 = %31) -> (i256, i256) { +// CHECK-NEXT: %53 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %55 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %54, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %56 = arith.addi %arg5, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %57 = arith.addi %arg6, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: scf.yield %56, %57 : i256, i256 loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %43 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %36, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %44 = arith.addi %arg2, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %45 = arith.addi %arg3, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: scf.yield %44, %45 : i256, i256 loc(#loc35) +// CHECK-NEXT: %50 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %38, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %51 = arith.addi %arg2, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: %52 = arith.addi %arg3, %c32_i256 : i256 loc(#loc35) +// CHECK-NEXT: scf.yield %51, %52 : i256, i256 loc(#loc35) // CHECK-NEXT: } loc(#loc35) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc36) // CHECK-NEXT: } loc(#loc32) // CHECK-NEXT: func.func @array_fixed_dyn_120(%arg0: i256 loc({{.*}}:27:27)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -3883,62 +4312,62 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc38) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc38) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc39) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc40) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc40) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc40) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc40) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc40) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc40) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc40) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc40) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc40) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc40) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc40) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc40) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc40) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc40) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc40) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc40) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc40) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc40) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc40) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc40) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) // CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc40) @@ -3948,122 +4377,149 @@ contract C { // CHECK-NEXT: %17 = arith.addi %15, %16 : i256 loc(#loc40) // CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc40) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc40) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc40) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc40) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc40) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) // CHECK-NEXT: %19 = arith.muli %14, %c32_i256 : i256 loc(#loc40) // CHECK-NEXT: %20 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc40) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) +// CHECK-NEXT: } loc(#loc40) +// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %23 = arith.addi %19, %c63_i256 : i256 loc(#loc40) +// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc40) +// CHECK-NEXT: %25 = arith.addi %22, %24 : i256 loc(#loc40) +// CHECK-NEXT: %26 = arith.cmpi ugt, %25, %c18446744073709551615_i256 : i256 loc(#loc40) +// CHECK-NEXT: %27 = arith.cmpi ult, %25, %22 : i256 loc(#loc40) +// CHECK-NEXT: %28 = arith.ori %26, %27 : i1 loc(#loc40) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %21 = arith.addi %19, %c32_i256 : i256 loc(#loc40) -// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %24 = arith.addi %23, %21 : i256 loc(#loc40) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %14, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %27 = arith.addi %23, %c32_i256 : i256 loc(#loc40) -// CHECK-NEXT: %28 = arith.index_castui %14 : i256 to index loc(#loc40) -// CHECK-NEXT: %29:2 = scf.for %arg1 = %c0 to %28 step %c1 iter_args(%arg2 = %27, %arg3 = %15) -> (i256, i256) { -// CHECK-NEXT: %30 = arith.addi %arg3, %c31_i256 : i256 loc(#loc40) -// CHECK-NEXT: %31 = arith.cmpi sge, %30, %5 : i256 loc(#loc40) -// CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc40) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc40) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc40) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc40) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %30 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %14, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %31 = arith.addi %22, %c32_i256 : i256 loc(#loc40) +// CHECK-NEXT: %32 = arith.index_castui %14 : i256 to index loc(#loc40) +// CHECK-NEXT: %33:2 = scf.for %arg1 = %c0 to %32 step %c1 iter_args(%arg2 = %31, %arg3 = %15) -> (i256, i256) { +// CHECK-NEXT: %34 = arith.addi %arg3, %c31_i256 : i256 loc(#loc40) +// CHECK-NEXT: %35 = arith.cmpi sge, %34, %5 : i256 loc(#loc40) +// CHECK-NEXT: scf.if %35 { +// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %52 = arith.addi %50, %c4_i256 : i256 loc(#loc40) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c32_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %54 = arith.addi %50, %c36_i256 : i256 loc(#loc40) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c43_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %56 = arith.addi %50, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %58 = arith.addi %50, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %60 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%60, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %34 = arith.addi %33, %c64_i256 : i256 loc(#loc40) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %36 = arith.addi %arg3, %c64_i256 : i256 loc(#loc40) -// CHECK-NEXT: %37 = arith.cmpi ugt, %36, %5 : i256 loc(#loc40) -// CHECK-NEXT: scf.if %37 { -// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc40) -// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc40) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc40) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc40) -// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %38 = arith.addi %37, %c64_i256 : i256 loc(#loc40) +// CHECK-NEXT: %39 = arith.cmpi ugt, %38, %c18446744073709551615_i256 : i256 loc(#loc40) +// CHECK-NEXT: %40 = arith.cmpi ult, %38, %37 : i256 loc(#loc40) +// CHECK-NEXT: %41 = arith.ori %39, %40 : i1 loc(#loc40) +// CHECK-NEXT: scf.if %41 { +// CHECK-NEXT: %49 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %50 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c65_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %51 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%51, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %38:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %33, %arg6 = %arg3) -> (i256, i256) { -// CHECK-NEXT: %42 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %44 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %45 = arith.addi %arg5, %c32_i256 : i256 loc(#loc40) -// CHECK-NEXT: %46 = arith.addi %arg6, %c32_i256 : i256 loc(#loc40) -// CHECK-NEXT: scf.yield %45, %46 : i256, i256 loc(#loc40) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %38, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %43 = arith.addi %arg3, %c64_i256 : i256 loc(#loc40) +// CHECK-NEXT: %44 = arith.cmpi ugt, %43, %5 : i256 loc(#loc40) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %52 = arith.addi %50, %c4_i256 : i256 loc(#loc40) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c32_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %54 = arith.addi %50, %c36_i256 : i256 loc(#loc40) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c43_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %56 = arith.addi %50, %c68_i256 : i256 loc(#loc40) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %58 = arith.addi %50, %c100_i256 : i256 loc(#loc40) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %60 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%60, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) +// CHECK-NEXT: } loc(#loc40) +// CHECK-NEXT: %45:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %37, %arg6 = %arg3) -> (i256, i256) { +// CHECK-NEXT: %49 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %51 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %50, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %52 = arith.addi %arg5, %c32_i256 : i256 loc(#loc40) +// CHECK-NEXT: %53 = arith.addi %arg6, %c32_i256 : i256 loc(#loc40) +// CHECK-NEXT: scf.yield %52, %53 : i256, i256 loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %39 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %33, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %40 = arith.addi %arg2, %c32_i256 : i256 loc(#loc40) -// CHECK-NEXT: %41 = arith.addi %arg3, %c64_i256 : i256 loc(#loc40) -// CHECK-NEXT: scf.yield %40, %41 : i256, i256 loc(#loc40) +// CHECK-NEXT: %46 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %37, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %47 = arith.addi %arg2, %c32_i256 : i256 loc(#loc40) +// CHECK-NEXT: %48 = arith.addi %arg3, %c64_i256 : i256 loc(#loc40) +// CHECK-NEXT: scf.yield %47, %48 : i256, i256 loc(#loc40) // CHECK-NEXT: } loc(#loc40) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc41) // CHECK-NEXT: } loc(#loc37) // CHECK-NEXT: func.func @array_dyn_dyn_98(%arg0: i256 loc({{.*}}:22:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -4085,62 +4541,62 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc43) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc43) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc44) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc45) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc45) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc45) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc45) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc45) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc45) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc45) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc45) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc45) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc45) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc45) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc45) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc45) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc45) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc45) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc45) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc45) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) // CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc45) @@ -4150,158 +4606,184 @@ contract C { // CHECK-NEXT: %17 = arith.addi %15, %16 : i256 loc(#loc45) // CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc45) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc45) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc45) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc45) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc45) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) // CHECK-NEXT: %19 = arith.muli %14, %c32_i256 : i256 loc(#loc45) // CHECK-NEXT: %20 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc45) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) +// CHECK-NEXT: } loc(#loc45) +// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) +// CHECK-NEXT: %23 = arith.addi %19, %c63_i256 : i256 loc(#loc45) +// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %25 = arith.addi %22, %24 : i256 loc(#loc45) +// CHECK-NEXT: %26 = arith.cmpi ugt, %25, %c18446744073709551615_i256 : i256 loc(#loc45) +// CHECK-NEXT: %27 = arith.cmpi ult, %25, %22 : i256 loc(#loc45) +// CHECK-NEXT: %28 = arith.ori %26, %27 : i1 loc(#loc45) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %21 = arith.addi %19, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %24 = arith.addi %23, %21 : i256 loc(#loc45) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %14, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %27 = arith.addi %23, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %28 = arith.index_castui %14 : i256 to index loc(#loc45) -// CHECK-NEXT: %29:2 = scf.for %arg1 = %c0 to %28 step %c1 iter_args(%arg2 = %27, %arg3 = %15) -> (i256, i256) { -// CHECK-NEXT: %30 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc45) -// CHECK-NEXT: scf.if %32 { -// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc45) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc45) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc45) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %30 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %14, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %31 = arith.addi %22, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %32 = arith.index_castui %14 : i256 to index loc(#loc45) +// CHECK-NEXT: %33:2 = scf.for %arg1 = %c0 to %32 step %c1 iter_args(%arg2 = %31, %arg3 = %15) -> (i256, i256) { +// CHECK-NEXT: %34 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) +// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %c18446744073709551615_i256 : i256 loc(#loc45) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) // CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc45) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc45) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %33 = arith.addi %15, %31 : i256 loc(#loc45) -// CHECK-NEXT: %34 = arith.addi %33, %c31_i256 : i256 loc(#loc45) -// CHECK-NEXT: %35 = arith.cmpi sge, %34, %5 : i256 loc(#loc45) -// CHECK-NEXT: scf.if %35 { -// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc45) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc45) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc45) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %37 = arith.addi %15, %35 : i256 loc(#loc45) +// CHECK-NEXT: %38 = arith.addi %37, %c31_i256 : i256 loc(#loc45) +// CHECK-NEXT: %39 = arith.cmpi sge, %38, %5 : i256 loc(#loc45) +// CHECK-NEXT: scf.if %39 { +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) // CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc45) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc45) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %36 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %38 = arith.addi %33, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %39 = arith.muli %37, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %40 = arith.addi %38, %39 : i256 loc(#loc45) -// CHECK-NEXT: %41 = arith.cmpi ugt, %40, %5 : i256 loc(#loc45) -// CHECK-NEXT: scf.if %41 { -// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %59 = arith.addi %57, %c4_i256 : i256 loc(#loc45) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c32_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %61 = arith.addi %57, %c36_i256 : i256 loc(#loc45) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c43_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %63 = arith.addi %57, %c68_i256 : i256 loc(#loc45) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %65 = arith.addi %57, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %40 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) +// CHECK-NEXT: %42 = arith.addi %37, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %43 = arith.muli %41, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %44 = arith.addi %42, %43 : i256 loc(#loc45) +// CHECK-NEXT: %45 = arith.cmpi ugt, %44, %5 : i256 loc(#loc45) +// CHECK-NEXT: scf.if %45 { +// CHECK-NEXT: %64 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) // CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %67 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%67, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %67 = arith.addi %65, %c4_i256 : i256 loc(#loc45) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c32_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %69 = arith.addi %65, %c36_i256 : i256 loc(#loc45) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c43_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %71 = arith.addi %65, %c68_i256 : i256 loc(#loc45) +// CHECK-NEXT: %72 = llvm.inttoptr %71 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %73 = arith.addi %65, %c100_i256 : i256 loc(#loc45) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %75 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%75, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %42 = arith.muli %37, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %43 = arith.cmpi ugt, %37, %c18446744073709551615_i256 : i256 loc(#loc45) -// CHECK-NEXT: scf.if %43 { -// CHECK-NEXT: %56 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %57 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %c65_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: "llvm.intrcall"(%58, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: %46 = arith.muli %41, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %47 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc45) +// CHECK-NEXT: scf.if %47 { +// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %65 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c65_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %66 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%66, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %44 = arith.addi %42, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %47 = arith.addi %46, %44 : i256 loc(#loc45) // CHECK-NEXT: %48 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %47, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %49 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %37, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %50 = arith.addi %46, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %51 = arith.index_castui %37 : i256 to index loc(#loc45) -// CHECK-NEXT: %52:2 = scf.for %arg4 = %c0 to %51 step %c1 iter_args(%arg5 = %50, %arg6 = %38) -> (i256, i256) { -// CHECK-NEXT: %56 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) -// CHECK-NEXT: %58 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %59 = arith.addi %arg5, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %60 = arith.addi %arg6, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: scf.yield %59, %60 : i256, i256 loc(#loc45) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) +// CHECK-NEXT: %50 = arith.addi %46, %c63_i256 : i256 loc(#loc45) +// CHECK-NEXT: %51 = arith.andi %50, %c-32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %52 = arith.addi %49, %51 : i256 loc(#loc45) +// CHECK-NEXT: %53 = arith.cmpi ugt, %52, %c18446744073709551615_i256 : i256 loc(#loc45) +// CHECK-NEXT: %54 = arith.cmpi ult, %52, %49 : i256 loc(#loc45) +// CHECK-NEXT: %55 = arith.ori %53, %54 : i1 loc(#loc45) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %65 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c65_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %66 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%66, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) +// CHECK-NEXT: } loc(#loc45) +// CHECK-NEXT: %56 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %52, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %57 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %41, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %58 = arith.addi %49, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %59 = arith.index_castui %41 : i256 to index loc(#loc45) +// CHECK-NEXT: %60:2 = scf.for %arg4 = %c0 to %59 step %c1 iter_args(%arg5 = %58, %arg6 = %42) -> (i256, i256) { +// CHECK-NEXT: %64 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %65 = llvm.load %64 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc45) +// CHECK-NEXT: %66 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %65, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %67 = arith.addi %arg5, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %68 = arith.addi %arg6, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: scf.yield %67, %68 : i256, i256 loc(#loc45) // CHECK-NEXT: } loc(#loc45) -// CHECK-NEXT: %53 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %46, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: %54 = arith.addi %arg2, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: %55 = arith.addi %arg3, %c32_i256 : i256 loc(#loc45) -// CHECK-NEXT: scf.yield %54, %55 : i256, i256 loc(#loc45) +// CHECK-NEXT: %61 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %49, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %62 = arith.addi %arg2, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: %63 = arith.addi %arg3, %c32_i256 : i256 loc(#loc45) +// CHECK-NEXT: scf.yield %62, %63 : i256, i256 loc(#loc45) // CHECK-NEXT: } loc(#loc45) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc46) // CHECK-NEXT: } loc(#loc42) @@ -4310,12 +4792,15 @@ contract C { // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) @@ -4330,142 +4815,168 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc48) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc48) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc49) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc50) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c128_i256 : i256 loc(#loc50) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc50) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc50) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c128_i256 : i256 loc(#loc50) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%16, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) // CHECK-NEXT: } loc(#loc50) // CHECK-NEXT: %7 = arith.addi %1, %c63_i256 : i256 loc(#loc50) // CHECK-NEXT: %8 = arith.cmpi sge, %7, %5 : i256 loc(#loc50) // CHECK-NEXT: scf.if %8 { -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %18 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %19 = arith.addi %17, %c4_i256 : i256 loc(#loc50) -// CHECK-NEXT: %20 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c32_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %21 = arith.addi %17, %c36_i256 : i256 loc(#loc50) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c43_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %23 = arith.addi %17, %c68_i256 : i256 loc(#loc50) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %25 = arith.addi %17, %c100_i256 : i256 loc(#loc50) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %27 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%27, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) +// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %22 = arith.addi %20, %c4_i256 : i256 loc(#loc50) +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c32_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %24 = arith.addi %20, %c36_i256 : i256 loc(#loc50) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c43_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %26 = arith.addi %20, %c68_i256 : i256 loc(#loc50) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %28 = arith.addi %20, %c100_i256 : i256 loc(#loc50) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %30 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: "llvm.intrcall"(%30, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) // CHECK-NEXT: } loc(#loc50) // CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) // CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) // CHECK-NEXT: %11 = arith.addi %10, %c64_i256 : i256 loc(#loc50) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %13 = arith.addi %1, %c160_i256 : i256 loc(#loc50) -// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %5 : i256 loc(#loc50) +// CHECK-NEXT: %12 = arith.cmpi ugt, %11, %c18446744073709551615_i256 : i256 loc(#loc50) +// CHECK-NEXT: %13 = arith.cmpi ult, %11, %10 : i256 loc(#loc50) +// CHECK-NEXT: %14 = arith.ori %12, %13 : i1 loc(#loc50) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %18 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %19 = arith.addi %17, %c4_i256 : i256 loc(#loc50) -// CHECK-NEXT: %20 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c32_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %21 = arith.addi %17, %c36_i256 : i256 loc(#loc50) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c43_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %23 = arith.addi %17, %c68_i256 : i256 loc(#loc50) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %25 = arith.addi %17, %c100_i256 : i256 loc(#loc50) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %27 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%27, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) +// CHECK-NEXT: } loc(#loc50) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %11, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %16 = arith.addi %1, %c160_i256 : i256 loc(#loc50) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %5 : i256 loc(#loc50) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) +// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %22 = arith.addi %20, %c4_i256 : i256 loc(#loc50) +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c32_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %24 = arith.addi %20, %c36_i256 : i256 loc(#loc50) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c43_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %26 = arith.addi %20, %c68_i256 : i256 loc(#loc50) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %28 = arith.addi %20, %c100_i256 : i256 loc(#loc50) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %30 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: "llvm.intrcall"(%30, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) // CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %10, %arg3 = %4) -> (i256, i256) { -// CHECK-NEXT: %16 = arith.addi %arg3, %c31_i256 : i256 loc(#loc50) -// CHECK-NEXT: %17 = arith.cmpi sge, %16, %5 : i256 loc(#loc50) -// CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %31 = arith.addi %29, %c4_i256 : i256 loc(#loc50) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c32_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %33 = arith.addi %29, %c36_i256 : i256 loc(#loc50) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c43_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %35 = arith.addi %29, %c68_i256 : i256 loc(#loc50) +// CHECK-NEXT: %18:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %10, %arg3 = %2) -> (i256, i256) { +// CHECK-NEXT: %19 = arith.addi %arg3, %c31_i256 : i256 loc(#loc50) +// CHECK-NEXT: %20 = arith.cmpi sge, %19, %5 : i256 loc(#loc50) +// CHECK-NEXT: scf.if %20 { +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %37 = arith.addi %29, %c100_i256 : i256 loc(#loc50) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc50) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %39 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%39, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc50) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc50) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc50) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) // CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %20 = arith.addi %19, %c64_i256 : i256 loc(#loc50) // CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %22 = arith.addi %arg3, %c64_i256 : i256 loc(#loc50) -// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %5 : i256 loc(#loc50) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %31 = arith.addi %29, %c4_i256 : i256 loc(#loc50) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c32_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %33 = arith.addi %29, %c36_i256 : i256 loc(#loc50) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c43_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %35 = arith.addi %29, %c68_i256 : i256 loc(#loc50) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) +// CHECK-NEXT: %23 = arith.addi %22, %c64_i256 : i256 loc(#loc50) +// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %c18446744073709551615_i256 : i256 loc(#loc50) +// CHECK-NEXT: %25 = arith.cmpi ult, %23, %22 : i256 loc(#loc50) +// CHECK-NEXT: %26 = arith.ori %24, %25 : i1 loc(#loc50) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) +// CHECK-NEXT: } loc(#loc50) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %28 = arith.addi %arg3, %c64_i256 : i256 loc(#loc50) +// CHECK-NEXT: %29 = arith.cmpi ugt, %28, %5 : i256 loc(#loc50) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %37 = arith.addi %29, %c100_i256 : i256 loc(#loc50) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc50) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %39 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%39, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc50) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc50) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc50) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) // CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: %24:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %19, %arg6 = %arg3) -> (i256, i256) { -// CHECK-NEXT: %28 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %30 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %31 = arith.addi %arg5, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: %32 = arith.addi %arg6, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: scf.yield %31, %32 : i256, i256 loc(#loc50) +// CHECK-NEXT: %30:2 = scf.for %arg4 = %c0 to %c2 step %c1 iter_args(%arg5 = %22, %arg6 = %arg3) -> (i256, i256) { +// CHECK-NEXT: %34 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) +// CHECK-NEXT: %36 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %37 = arith.addi %arg5, %c32_i256 : i256 loc(#loc50) +// CHECK-NEXT: %38 = arith.addi %arg6, %c32_i256 : i256 loc(#loc50) +// CHECK-NEXT: scf.yield %37, %38 : i256, i256 loc(#loc50) // CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: llvm.store %19, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: %27 = arith.addi %arg3, %c64_i256 : i256 loc(#loc50) -// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc50) +// CHECK-NEXT: %31 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: llvm.store %22, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc50) +// CHECK-NEXT: %32 = arith.addi %arg2, %c32_i256 : i256 loc(#loc50) +// CHECK-NEXT: %33 = arith.addi %arg3, %c64_i256 : i256 loc(#loc50) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc50) // CHECK-NEXT: } loc(#loc50) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc51) // CHECK-NEXT: } loc(#loc47) // CHECK-NEXT: func.func @array_dyn_54(%arg0: i256 loc({{.*}}:12:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -4487,62 +4998,62 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc53) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc53) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc54) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc55) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc55) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc55) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc55) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc55) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc55) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc55) // CHECK-NEXT: } loc(#loc55) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc55) // CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) // CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc55) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc55) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc55) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc55) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc55) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc55) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc55) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc55) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc55) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc55) // CHECK-NEXT: } loc(#loc55) -// CHECK-NEXT: %10 = arith.addi %4, %8 : i256 loc(#loc55) +// CHECK-NEXT: %10 = arith.addi %2, %8 : i256 loc(#loc55) // CHECK-NEXT: %11 = arith.addi %10, %c31_i256 : i256 loc(#loc55) // CHECK-NEXT: %12 = arith.cmpi sge, %11, %5 : i256 loc(#loc55) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc55) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc55) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc55) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc55) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc55) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc55) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc55) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc55) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc55) // CHECK-NEXT: } loc(#loc55) // CHECK-NEXT: %13 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc55) @@ -4552,55 +5063,68 @@ contract C { // CHECK-NEXT: %17 = arith.addi %15, %16 : i256 loc(#loc55) // CHECK-NEXT: %18 = arith.cmpi ugt, %17, %5 : i256 loc(#loc55) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %33 = arith.addi %31, %c4_i256 : i256 loc(#loc55) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c32_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %35 = arith.addi %31, %c36_i256 : i256 loc(#loc55) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) // CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c43_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %37 = arith.addi %31, %c68_i256 : i256 loc(#loc55) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc55) // CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %39 = arith.addi %31, %c100_i256 : i256 loc(#loc55) +// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc55) // CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %41 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: "llvm.intrcall"(%41, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) +// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc55) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc55) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc55) // CHECK-NEXT: } loc(#loc55) // CHECK-NEXT: %19 = arith.muli %14, %c32_i256 : i256 loc(#loc55) // CHECK-NEXT: %20 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc55) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc55) +// CHECK-NEXT: } loc(#loc55) +// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) +// CHECK-NEXT: %23 = arith.addi %19, %c63_i256 : i256 loc(#loc55) +// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc55) +// CHECK-NEXT: %25 = arith.addi %22, %24 : i256 loc(#loc55) +// CHECK-NEXT: %26 = arith.cmpi ugt, %25, %c18446744073709551615_i256 : i256 loc(#loc55) +// CHECK-NEXT: %27 = arith.cmpi ult, %25, %22 : i256 loc(#loc55) +// CHECK-NEXT: %28 = arith.ori %26, %27 : i1 loc(#loc55) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc55) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc55) // CHECK-NEXT: } loc(#loc55) -// CHECK-NEXT: %21 = arith.addi %19, %c32_i256 : i256 loc(#loc55) -// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) -// CHECK-NEXT: %24 = arith.addi %23, %21 : i256 loc(#loc55) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %26 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %14, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %27 = arith.addi %23, %c32_i256 : i256 loc(#loc55) -// CHECK-NEXT: %28 = arith.index_castui %14 : i256 to index loc(#loc55) -// CHECK-NEXT: %29:2 = scf.for %arg1 = %c0 to %28 step %c1 iter_args(%arg2 = %27, %arg3 = %15) -> (i256, i256) { -// CHECK-NEXT: %30 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) -// CHECK-NEXT: %32 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) -// CHECK-NEXT: %33 = arith.addi %arg2, %c32_i256 : i256 loc(#loc55) -// CHECK-NEXT: %34 = arith.addi %arg3, %c32_i256 : i256 loc(#loc55) -// CHECK-NEXT: scf.yield %33, %34 : i256, i256 loc(#loc55) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %25, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %30 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %14, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %31 = arith.addi %22, %c32_i256 : i256 loc(#loc55) +// CHECK-NEXT: %32 = arith.index_castui %14 : i256 to index loc(#loc55) +// CHECK-NEXT: %33:2 = scf.for %arg1 = %c0 to %32 step %c1 iter_args(%arg2 = %31, %arg3 = %15) -> (i256, i256) { +// CHECK-NEXT: %34 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc55) +// CHECK-NEXT: %36 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc55) +// CHECK-NEXT: %37 = arith.addi %arg2, %c32_i256 : i256 loc(#loc55) +// CHECK-NEXT: %38 = arith.addi %arg3, %c32_i256 : i256 loc(#loc55) +// CHECK-NEXT: scf.yield %37, %38 : i256, i256 loc(#loc55) // CHECK-NEXT: } loc(#loc55) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc56) // CHECK-NEXT: } loc(#loc52) @@ -4609,12 +5133,15 @@ contract C { // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) @@ -4627,75 +5154,87 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc58) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc58) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc59) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc60) -// CHECK-NEXT: %5 = arith.addi %4, %3 : i256 loc(#loc60) -// CHECK-NEXT: %6 = arith.cmpi slt, %3, %c64_i256 : i256 loc(#loc60) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %5 = arith.addi %2, %4 : i256 loc(#loc60) +// CHECK-NEXT: %6 = arith.cmpi slt, %4, %c64_i256 : i256 loc(#loc60) // CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: "llvm.intrcall"(%16, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) // CHECK-NEXT: } loc(#loc60) // CHECK-NEXT: %7 = arith.addi %1, %c63_i256 : i256 loc(#loc60) // CHECK-NEXT: %8 = arith.cmpi sge, %7, %5 : i256 loc(#loc60) // CHECK-NEXT: scf.if %8 { -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) -// CHECK-NEXT: %18 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %19 = arith.addi %17, %c4_i256 : i256 loc(#loc60) -// CHECK-NEXT: %20 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c32_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %21 = arith.addi %17, %c36_i256 : i256 loc(#loc60) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c43_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %23 = arith.addi %17, %c68_i256 : i256 loc(#loc60) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %25 = arith.addi %17, %c100_i256 : i256 loc(#loc60) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %27 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: "llvm.intrcall"(%27, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %22 = arith.addi %20, %c4_i256 : i256 loc(#loc60) +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c32_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %24 = arith.addi %20, %c36_i256 : i256 loc(#loc60) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c43_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %26 = arith.addi %20, %c68_i256 : i256 loc(#loc60) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %28 = arith.addi %20, %c100_i256 : i256 loc(#loc60) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %30 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%30, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) // CHECK-NEXT: } loc(#loc60) // CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) // CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) // CHECK-NEXT: %11 = arith.addi %10, %c64_i256 : i256 loc(#loc60) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %13 = arith.addi %1, %c96_i256 : i256 loc(#loc60) -// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %5 : i256 loc(#loc60) +// CHECK-NEXT: %12 = arith.cmpi ugt, %11, %c18446744073709551615_i256 : i256 loc(#loc60) +// CHECK-NEXT: %13 = arith.cmpi ult, %11, %10 : i256 loc(#loc60) +// CHECK-NEXT: %14 = arith.ori %12, %13 : i1 loc(#loc60) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) -// CHECK-NEXT: %18 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %19 = arith.addi %17, %c4_i256 : i256 loc(#loc60) -// CHECK-NEXT: %20 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c32_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %21 = arith.addi %17, %c36_i256 : i256 loc(#loc60) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c43_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %23 = arith.addi %17, %c68_i256 : i256 loc(#loc60) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %25 = arith.addi %17, %c100_i256 : i256 loc(#loc60) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %27 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: "llvm.intrcall"(%27, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) +// CHECK-NEXT: } loc(#loc60) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %11, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %16 = arith.addi %1, %c96_i256 : i256 loc(#loc60) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %5 : i256 loc(#loc60) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %22 = arith.addi %20, %c4_i256 : i256 loc(#loc60) +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c32_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %24 = arith.addi %20, %c36_i256 : i256 loc(#loc60) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c43_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %26 = arith.addi %20, %c68_i256 : i256 loc(#loc60) +// CHECK-NEXT: %27 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %28 = arith.addi %20, %c100_i256 : i256 loc(#loc60) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %30 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%30, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) // CHECK-NEXT: } loc(#loc60) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %10, %arg3 = %4) -> (i256, i256) { -// CHECK-NEXT: %16 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) -// CHECK-NEXT: %18 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %19 = arith.addi %arg2, %c32_i256 : i256 loc(#loc60) -// CHECK-NEXT: %20 = arith.addi %arg3, %c32_i256 : i256 loc(#loc60) -// CHECK-NEXT: scf.yield %19, %20 : i256, i256 loc(#loc60) +// CHECK-NEXT: %18:2 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %10, %arg3 = %2) -> (i256, i256) { +// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %21 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %22 = arith.addi %arg2, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: %23 = arith.addi %arg3, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: scf.yield %22, %23 : i256, i256 loc(#loc60) // CHECK-NEXT: } loc(#loc60) // CHECK-NEXT: return %c0_i256 : i256 loc(#loc61) // CHECK-NEXT: } loc(#loc57) diff --git a/test/lit/mlirCodegen/EVM/array.sol b/test/lit/mlirCodegen/EVM/array.sol index f2f4a0418..42553c37c 100644 --- a/test/lit/mlirCodegen/EVM/array.sol +++ b/test/lit/mlirCodegen/EVM/array.sol @@ -184,6 +184,12 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: return loc(#loc14) // CHECK-NEXT: } loc(#loc14) // CHECK-NEXT: func.func @malloc_1d_65() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc21) @@ -191,43 +197,85 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc21) // CHECK-NEXT: %3 = arith.addi %2, %c96_i256 : i256 loc(#loc21) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %5 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc21) -// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc21) -// CHECK-NEXT: %7 = llvm.inttoptr %5 : i256 to !llvm.ptr<2> loc(#loc21) -// CHECK-NEXT: "llvm.intr.memcpy"(%6, %7, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc21) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc21) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc21) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc21) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: llvm.store %c65_i256, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: "llvm.intrcall"(%13, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc21) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc21) +// CHECK-NEXT: } loc(#loc21) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc21) +// CHECK-NEXT: %9 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc21) +// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<2> loc(#loc21) +// CHECK-NEXT: "llvm.intr.memcpy"(%9, %10, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc21) // CHECK-NEXT: llvm.store %2, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc21) // CHECK-NEXT: return loc(#loc20) // CHECK-NEXT: } loc(#loc20) // CHECK-NEXT: func.func @malloc_2d_78() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c128 = arith.constant 128 : index loc(#loc) +// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc23) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc23) // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc23) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc23) // CHECK-NEXT: %3 = arith.addi %2, %c128_i256 : i256 loc(#loc23) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc23) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc23) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc23) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc23) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %8 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %9 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: llvm.store %c65_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: "llvm.intrcall"(%10, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc23) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc23) +// CHECK-NEXT: } loc(#loc23) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) // CHECK-NEXT: scf.for %arg0 = %c0 to %c128 step %c32 { -// CHECK-NEXT: %5 = arith.index_castui %arg0 : index to i256 loc(#loc23) -// CHECK-NEXT: %6 = arith.addi %2, %5 : i256 loc(#loc23) -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc23) -// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc23) -// CHECK-NEXT: %9 = arith.addi %8, %c96_i256 : i256 loc(#loc23) +// CHECK-NEXT: %8 = arith.index_castui %arg0 : index to i256 loc(#loc23) +// CHECK-NEXT: %9 = arith.addi %2, %8 : i256 loc(#loc23) // CHECK-NEXT: %10 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc23) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) -// CHECK-NEXT: %11 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc23) -// CHECK-NEXT: %12 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc23) -// CHECK-NEXT: %13 = llvm.inttoptr %11 : i256 to !llvm.ptr<2> loc(#loc23) -// CHECK-NEXT: "llvm.intr.memcpy"(%12, %13, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc23) -// CHECK-NEXT: %14 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc23) -// CHECK-NEXT: llvm.store %8, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc23) +// CHECK-NEXT: %12 = arith.addi %11, %c96_i256 : i256 loc(#loc23) +// CHECK-NEXT: %13 = arith.cmpi ugt, %12, %c18446744073709551615_i256 : i256 loc(#loc23) +// CHECK-NEXT: %14 = arith.cmpi ult, %12, %11 : i256 loc(#loc23) +// CHECK-NEXT: %15 = arith.ori %13, %14 : i1 loc(#loc23) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc23) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc23) +// CHECK-NEXT: } loc(#loc23) +// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: llvm.store %12, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %17 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc23) +// CHECK-NEXT: %18 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: %19 = llvm.inttoptr %17 : i256 to !llvm.ptr<2> loc(#loc23) +// CHECK-NEXT: "llvm.intr.memcpy"(%18, %19, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc23) +// CHECK-NEXT: %20 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc23) +// CHECK-NEXT: llvm.store %11, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc23) // CHECK-NEXT: } loc(#loc23) // CHECK-NEXT: llvm.store %2, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc23) // CHECK-NEXT: return loc(#loc22) @@ -236,11 +284,13 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c5_i256 = arith.constant 5 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c50_i256 = arith.constant 50 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) @@ -250,60 +300,74 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc26) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) // CHECK-NEXT: %3 = arith.addi %2, %c192_i256 : i256 loc(#loc26) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: llvm.store %c5_i256, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %6 = arith.addi %2, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %7 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc26) -// CHECK-NEXT: %8 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %9 = llvm.inttoptr %7 : i256 to !llvm.ptr<2> loc(#loc26) -// CHECK-NEXT: "llvm.intr.memcpy"(%8, %9, %c160_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc26) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc26) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc26) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc26) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc26) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc26) +// CHECK-NEXT: } loc(#loc26) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: %8 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: llvm.store %c5_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: %9 = arith.addi %2, %c32_i256 : i256 loc(#loc26) +// CHECK-NEXT: %10 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc26) +// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<2> loc(#loc26) +// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %c160_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc26) // CHECK-NEXT: llvm.store %2, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc27) -// CHECK-NEXT: %10 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc28) -// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc28) -// CHECK-NEXT: %13 = arith.cmpi ule, %12, %c0_i256 : i256 loc(#loc28) -// CHECK-NEXT: scf.if %13 { -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: llvm.store %c50_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc28) +// CHECK-NEXT: %13 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc28) +// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc28) +// CHECK-NEXT: %16 = arith.cmpi ule, %15, %c0_i256 : i256 loc(#loc28) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: llvm.store %c50_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc28) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc28) // CHECK-NEXT: } loc(#loc28) -// CHECK-NEXT: %14 = arith.addi %10, %c32_i256 : i256 loc(#loc28) -// CHECK-NEXT: %15 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: llvm.store %c1_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc28) -// CHECK-NEXT: %16 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc29) -// CHECK-NEXT: %17 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) -// CHECK-NEXT: %19 = arith.cmpi ule, %18, %c0_i256 : i256 loc(#loc29) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %c50_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) +// CHECK-NEXT: %17 = arith.addi %13, %c32_i256 : i256 loc(#loc28) +// CHECK-NEXT: %18 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: llvm.store %c1_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc28) +// CHECK-NEXT: %19 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc29) +// CHECK-NEXT: %20 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: %22 = arith.cmpi ule, %21, %c0_i256 : i256 loc(#loc29) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: llvm.store %c50_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc29) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc29) // CHECK-NEXT: } loc(#loc29) -// CHECK-NEXT: %20 = arith.addi %16, %c32_i256 : i256 loc(#loc29) -// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) -// CHECK-NEXT: return %22 : i256 loc(#loc30) +// CHECK-NEXT: %23 = arith.addi %19, %c32_i256 : i256 loc(#loc29) +// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc29) +// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) +// CHECK-NEXT: return %25 : i256 loc(#loc30) // CHECK-NEXT: } loc(#loc24) // CHECK-NEXT: func.func @new_2d_164() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c64 = arith.constant 64 : index loc(#loc) // CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c50_i256 = arith.constant 50 : i256 loc(#loc) +// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) @@ -313,141 +377,183 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc33) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc33) // CHECK-NEXT: %3 = arith.addi %2, %c96_i256 : i256 loc(#loc33) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: llvm.store %c2_i256, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %6 = arith.addi %2, %c32_i256 : i256 loc(#loc33) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc33) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc33) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc33) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %c65_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc33) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc33) +// CHECK-NEXT: } loc(#loc33) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %8 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %c2_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %9 = arith.addi %2, %c32_i256 : i256 loc(#loc33) // CHECK-NEXT: scf.for %arg0 = %c0 to %c64 step %c32 { -// CHECK-NEXT: %62 = arith.index_castui %arg0 : index to i256 loc(#loc33) -// CHECK-NEXT: %63 = arith.addi %6, %62 : i256 loc(#loc33) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: llvm.store %c96_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %71 = arith.index_castui %arg0 : index to i256 loc(#loc33) +// CHECK-NEXT: %72 = arith.addi %9, %71 : i256 loc(#loc33) +// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %c96_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) // CHECK-NEXT: } loc(#loc33) // CHECK-NEXT: llvm.store %2, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc34) -// CHECK-NEXT: %7 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc35) -// CHECK-NEXT: %8 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %9 = llvm.load %8 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) -// CHECK-NEXT: %10 = arith.cmpi ule, %9, %c0_i256 : i256 loc(#loc35) -// CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %63 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %c50_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: "llvm.intrcall"(%64, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) +// CHECK-NEXT: %10 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc35) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc35) +// CHECK-NEXT: %13 = arith.cmpi ule, %12, %c0_i256 : i256 loc(#loc35) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %c50_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc35) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc35) // CHECK-NEXT: } loc(#loc35) -// CHECK-NEXT: %11 = arith.addi %7, %c32_i256 : i256 loc(#loc35) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc36) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc36) -// CHECK-NEXT: %14 = arith.addi %13, %c96_i256 : i256 loc(#loc36) +// CHECK-NEXT: %14 = arith.addi %10, %c32_i256 : i256 loc(#loc35) // CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc36) -// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc36) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc36) -// CHECK-NEXT: llvm.store %c2_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc36) -// CHECK-NEXT: %17 = arith.addi %13, %c32_i256 : i256 loc(#loc36) -// CHECK-NEXT: %18 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc36) -// CHECK-NEXT: %19 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc36) -// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<2> loc(#loc36) -// CHECK-NEXT: "llvm.intr.memcpy"(%19, %20, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc36) -// CHECK-NEXT: %21 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: llvm.store %13, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) -// CHECK-NEXT: %22 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc37) -// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc37) -// CHECK-NEXT: %25 = arith.cmpi ule, %24, %c1_i256 : i256 loc(#loc37) -// CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: %63 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: llvm.store %c50_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: "llvm.intrcall"(%64, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc37) +// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc36) +// CHECK-NEXT: %17 = arith.addi %16, %c96_i256 : i256 loc(#loc36) +// CHECK-NEXT: %18 = arith.cmpi ugt, %17, %c18446744073709551615_i256 : i256 loc(#loc36) +// CHECK-NEXT: %19 = arith.cmpi ult, %17, %16 : i256 loc(#loc36) +// CHECK-NEXT: %20 = arith.ori %18, %19 : i1 loc(#loc36) +// CHECK-NEXT: scf.if %20 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: llvm.store %c65_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc36) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc36) +// CHECK-NEXT: } loc(#loc36) +// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: %22 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: llvm.store %c2_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: %23 = arith.addi %16, %c32_i256 : i256 loc(#loc36) +// CHECK-NEXT: %24 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc36) +// CHECK-NEXT: %25 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc36) +// CHECK-NEXT: %26 = llvm.inttoptr %24 : i256 to !llvm.ptr<2> loc(#loc36) +// CHECK-NEXT: "llvm.intr.memcpy"(%25, %26, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc36) +// CHECK-NEXT: %27 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: llvm.store %16, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc35) +// CHECK-NEXT: %28 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc37) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc37) +// CHECK-NEXT: %31 = arith.cmpi ule, %30, %c1_i256 : i256 loc(#loc37) +// CHECK-NEXT: scf.if %31 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: llvm.store %c50_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc37) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc37) // CHECK-NEXT: } loc(#loc37) -// CHECK-NEXT: %26 = arith.addi %22, %c64_i256 : i256 loc(#loc37) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc38) -// CHECK-NEXT: %29 = arith.addi %28, %c96_i256 : i256 loc(#loc38) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc38) -// CHECK-NEXT: llvm.store %c2_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc38) -// CHECK-NEXT: %33 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc38) -// CHECK-NEXT: %34 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc38) -// CHECK-NEXT: %35 = llvm.inttoptr %33 : i256 to !llvm.ptr<2> loc(#loc38) -// CHECK-NEXT: "llvm.intr.memcpy"(%34, %35, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc38) -// CHECK-NEXT: %36 = llvm.inttoptr %26 : i256 to !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: llvm.store %28, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc37) -// CHECK-NEXT: %37 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc39) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %40 = arith.cmpi ule, %39, %c0_i256 : i256 loc(#loc39) -// CHECK-NEXT: scf.if %40 { -// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %63 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: llvm.store %c50_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: "llvm.intrcall"(%64, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) +// CHECK-NEXT: %32 = arith.addi %28, %c64_i256 : i256 loc(#loc37) +// CHECK-NEXT: %33 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc38) +// CHECK-NEXT: %35 = arith.addi %34, %c96_i256 : i256 loc(#loc38) +// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %c18446744073709551615_i256 : i256 loc(#loc38) +// CHECK-NEXT: %37 = arith.cmpi ult, %35, %34 : i256 loc(#loc38) +// CHECK-NEXT: %38 = arith.ori %36, %37 : i1 loc(#loc38) +// CHECK-NEXT: scf.if %38 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %c65_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc38) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc38) +// CHECK-NEXT: } loc(#loc38) +// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %35, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %40 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %c2_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %41 = arith.addi %34, %c32_i256 : i256 loc(#loc38) +// CHECK-NEXT: %42 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc38) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %44 = llvm.inttoptr %42 : i256 to !llvm.ptr<2> loc(#loc38) +// CHECK-NEXT: "llvm.intr.memcpy"(%43, %44, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc38) +// CHECK-NEXT: %45 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: llvm.store %34, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc37) +// CHECK-NEXT: %46 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc39) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %49 = arith.cmpi ule, %48, %c0_i256 : i256 loc(#loc39) +// CHECK-NEXT: scf.if %49 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c50_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) // CHECK-NEXT: } loc(#loc39) -// CHECK-NEXT: %41 = arith.addi %37, %c32_i256 : i256 loc(#loc39) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %46 = arith.cmpi ule, %45, %c1_i256 : i256 loc(#loc39) -// CHECK-NEXT: scf.if %46 { -// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %63 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: llvm.store %c50_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: "llvm.intrcall"(%64, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) +// CHECK-NEXT: %50 = arith.addi %46, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %54 = llvm.load %53 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %55 = arith.cmpi ule, %54, %c1_i256 : i256 loc(#loc39) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c50_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) // CHECK-NEXT: } loc(#loc39) -// CHECK-NEXT: %47 = arith.addi %43, %c64_i256 : i256 loc(#loc39) -// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: llvm.store %c1_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %49 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc40) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %51 = llvm.load %50 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %52 = arith.cmpi ule, %51, %c0_i256 : i256 loc(#loc40) -// CHECK-NEXT: scf.if %52 { -// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %63 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c50_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%64, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: %56 = arith.addi %52, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c1_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %58 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc40) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %60 = llvm.load %59 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %61 = arith.cmpi ule, %60, %c0_i256 : i256 loc(#loc40) +// CHECK-NEXT: scf.if %61 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c50_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %53 = arith.addi %49, %c32_i256 : i256 loc(#loc40) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %57 = llvm.load %56 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: %58 = arith.cmpi ule, %57, %c1_i256 : i256 loc(#loc40) -// CHECK-NEXT: scf.if %58 { -// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %63 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: llvm.store %c50_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %64 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: "llvm.intrcall"(%64, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) +// CHECK-NEXT: %62 = arith.addi %58, %c32_i256 : i256 loc(#loc40) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %64 = llvm.load %63 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: %67 = arith.cmpi ule, %66, %c1_i256 : i256 loc(#loc40) +// CHECK-NEXT: scf.if %67 { +// CHECK-NEXT: %71 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %72 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: llvm.store %c50_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %73 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: "llvm.intrcall"(%73, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc40) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc40) // CHECK-NEXT: } loc(#loc40) -// CHECK-NEXT: %59 = arith.addi %55, %c64_i256 : i256 loc(#loc40) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc40) -// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) -// CHECK-NEXT: return %61 : i256 loc(#loc41) +// CHECK-NEXT: %68 = arith.addi %64, %c64_i256 : i256 loc(#loc40) +// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc40) +// CHECK-NEXT: %70 = llvm.load %69 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc40) +// CHECK-NEXT: return %70 : i256 loc(#loc41) // CHECK-NEXT: } loc(#loc31) // CHECK-NEXT: func.func @len_199() -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) // CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) @@ -457,34 +563,64 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) // CHECK-NEXT: %3 = arith.addi %2, %c96_i256 : i256 loc(#loc44) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %c2_i256, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %6 = arith.addi %2, %c32_i256 : i256 loc(#loc44) -// CHECK-NEXT: %7 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc44) -// CHECK-NEXT: %8 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %9 = llvm.inttoptr %7 : i256 to !llvm.ptr<2> loc(#loc44) -// CHECK-NEXT: "llvm.intr.memcpy"(%8, %9, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc44) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc44) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc44) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc44) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc44) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %8 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: llvm.store %c2_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %9 = arith.addi %2, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %10 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc44) +// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<2> loc(#loc44) +// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc44) // CHECK-NEXT: llvm.store %2, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc45) -// CHECK-NEXT: %10 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc46) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc46) -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc46) -// CHECK-NEXT: %13 = arith.addi %12, %c96_i256 : i256 loc(#loc46) +// CHECK-NEXT: %13 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc46) // CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc46) -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc46) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc46) -// CHECK-NEXT: %16 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc46) -// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc46) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc46) -// CHECK-NEXT: llvm.store %12, %10 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc46) -// CHECK-NEXT: %18 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc47) -// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc47) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc47) -// CHECK-NEXT: return %20, %c3_i256 : i256, i256 loc(#loc48) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc46) +// CHECK-NEXT: %16 = arith.addi %15, %c96_i256 : i256 loc(#loc46) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc46) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %15 : i256 loc(#loc46) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc46) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc46) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc46) +// CHECK-NEXT: } loc(#loc46) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: %21 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc46) +// CHECK-NEXT: %22 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc46) +// CHECK-NEXT: %23 = llvm.inttoptr %21 : i256 to !llvm.ptr<2> loc(#loc46) +// CHECK-NEXT: "llvm.intr.memcpy"(%22, %23, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc46) +// CHECK-NEXT: llvm.store %15, %13 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc46) +// CHECK-NEXT: %24 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc47) +// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc47) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc47) +// CHECK-NEXT: return %26, %c3_i256 : i256, i256 loc(#loc48) // CHECK-NEXT: } loc(#loc42) // CHECK-NEXT: func.func @lit_226() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc50) @@ -494,21 +630,39 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc53) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc53) // CHECK-NEXT: %4 = arith.addi %3, %c64_i256 : i256 loc(#loc53) -// CHECK-NEXT: %5 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc53) -// CHECK-NEXT: llvm.store %4, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) -// CHECK-NEXT: %6 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc53) -// CHECK-NEXT: llvm.store %c1_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) -// CHECK-NEXT: %7 = arith.addi %3, %c32_i256 : i256 loc(#loc53) -// CHECK-NEXT: %8 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc53) -// CHECK-NEXT: llvm.store %1, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) -// CHECK-NEXT: %9 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc54) -// CHECK-NEXT: llvm.store %3, %9 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc54) -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc55) -// CHECK-NEXT: return %10 : i256 loc(#loc56) +// CHECK-NEXT: %5 = arith.cmpi ugt, %4, %c18446744073709551615_i256 : i256 loc(#loc53) +// CHECK-NEXT: %6 = arith.cmpi ult, %4, %3 : i256 loc(#loc53) +// CHECK-NEXT: %7 = arith.ori %5, %6 : i1 loc(#loc53) +// CHECK-NEXT: scf.if %7 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc53) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc53) +// CHECK-NEXT: } loc(#loc53) +// CHECK-NEXT: %8 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: llvm.store %4, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: llvm.store %c1_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: %10 = arith.addi %3, %c32_i256 : i256 loc(#loc53) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: llvm.store %1, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc53) +// CHECK-NEXT: %12 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc54) +// CHECK-NEXT: llvm.store %3, %12 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc54) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc55) +// CHECK-NEXT: return %13 : i256 loc(#loc56) // CHECK-NEXT: } loc(#loc49) // CHECK-NEXT: func.func @lit_2d_258() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c21_i256 = arith.constant 21 : i256 loc(#loc) // CHECK-NEXT: %c20_i256 = arith.constant 20 : i256 loc(#loc) // CHECK-NEXT: %c10_i256 = arith.constant 10 : i256 loc(#loc58) @@ -517,35 +671,71 @@ function stg_arr(uint[] storage a) returns (uint, uint) { // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) // CHECK-NEXT: %2 = arith.addi %1, %c64_i256 : i256 loc(#loc60) -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %2, %3 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %4 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c10_i256, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %5 = arith.addi %1, %c32_i256 : i256 loc(#loc60) -// CHECK-NEXT: %6 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: llvm.store %c11_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc61) -// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc61) -// CHECK-NEXT: %9 = arith.addi %8, %c64_i256 : i256 loc(#loc61) +// CHECK-NEXT: %3 = arith.cmpi ugt, %2, %c18446744073709551615_i256 : i256 loc(#loc60) +// CHECK-NEXT: %4 = arith.cmpi ult, %2, %1 : i256 loc(#loc60) +// CHECK-NEXT: %5 = arith.ori %3, %4 : i1 loc(#loc60) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %32 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c65_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%33, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) +// CHECK-NEXT: } loc(#loc60) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %2, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %7 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c10_i256, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: llvm.store %c11_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc60) // CHECK-NEXT: %10 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc61) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) -// CHECK-NEXT: %11 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc61) -// CHECK-NEXT: llvm.store %c20_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) -// CHECK-NEXT: %12 = arith.addi %8, %c32_i256 : i256 loc(#loc61) -// CHECK-NEXT: %13 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc61) -// CHECK-NEXT: llvm.store %c21_i256, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc62) -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc62) -// CHECK-NEXT: %16 = arith.addi %15, %c64_i256 : i256 loc(#loc62) -// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc62) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) -// CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc62) -// CHECK-NEXT: llvm.store %1, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) -// CHECK-NEXT: %19 = arith.addi %15, %c32_i256 : i256 loc(#loc62) -// CHECK-NEXT: %20 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc62) -// CHECK-NEXT: llvm.store %8, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) -// CHECK-NEXT: %21 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc63) -// CHECK-NEXT: llvm.store %15, %21 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc63) +// CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc61) +// CHECK-NEXT: %12 = arith.addi %11, %c64_i256 : i256 loc(#loc61) +// CHECK-NEXT: %13 = arith.cmpi ugt, %12, %c18446744073709551615_i256 : i256 loc(#loc61) +// CHECK-NEXT: %14 = arith.cmpi ult, %12, %11 : i256 loc(#loc61) +// CHECK-NEXT: %15 = arith.ori %13, %14 : i1 loc(#loc61) +// CHECK-NEXT: scf.if %15 { +// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: %32 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: llvm.store %c65_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: "llvm.intrcall"(%33, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc61) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc61) +// CHECK-NEXT: } loc(#loc61) +// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: llvm.store %12, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: %17 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: llvm.store %c20_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: %18 = arith.addi %11, %c32_i256 : i256 loc(#loc61) +// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: llvm.store %c21_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc61) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc62) +// CHECK-NEXT: %22 = arith.addi %21, %c64_i256 : i256 loc(#loc62) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc62) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %21 : i256 loc(#loc62) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc62) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: %32 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: llvm.store %c65_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: "llvm.intrcall"(%33, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc62) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc62) +// CHECK-NEXT: } loc(#loc62) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: %27 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: llvm.store %1, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: %28 = arith.addi %21, %c32_i256 : i256 loc(#loc62) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: llvm.store %11, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc62) +// CHECK-NEXT: %30 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc63) +// CHECK-NEXT: llvm.store %21, %30 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc63) // CHECK-NEXT: return loc(#loc57) // CHECK-NEXT: } loc(#loc57) // CHECK-NEXT: func.func @cd_arr_276(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:50:16)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { diff --git a/test/lit/mlirCodegen/EVM/assert.sol b/test/lit/mlirCodegen/EVM/assert.sol index 5c465ff68..85904d8ae 100644 --- a/test/lit/mlirCodegen/EVM/assert.sol +++ b/test/lit/mlirCodegen/EVM/assert.sol @@ -14,6 +14,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -22,8 +29,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_17"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -31,22 +38,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_17() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_17_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_17_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_17_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_17_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/assgn.sol b/test/lit/mlirCodegen/EVM/assgn.sol index 4f95d2090..874452273 100644 --- a/test/lit/mlirCodegen/EVM/assgn.sol +++ b/test/lit/mlirCodegen/EVM/assgn.sol @@ -22,6 +22,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -30,8 +37,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -39,22 +46,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_49() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_49_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_49_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/balance.sol b/test/lit/mlirCodegen/EVM/balance.sol index 7ade2e75c..bbc92d077 100644 --- a/test/lit/mlirCodegen/EVM/balance.sol +++ b/test/lit/mlirCodegen/EVM/balance.sol @@ -12,6 +12,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -20,8 +27,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_13"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -29,22 +36,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_13() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_13_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_13_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_13_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_13_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/bare-calls.sol b/test/lit/mlirCodegen/EVM/bare-calls.sol index beb72ba48..9ac309164 100644 --- a/test/lit/mlirCodegen/EVM/bare-calls.sol +++ b/test/lit/mlirCodegen/EVM/bare-calls.sol @@ -44,6 +44,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -52,8 +59,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_145"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -61,22 +68,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_145() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_145_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_145_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_145_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_145_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -234,11 +255,17 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @staticcall_144(%arg0: i256 loc({{.*}}:25:22)) -> (i1, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c-57376585569545145944295328828381171477604071846055643819493376494671449030656_i256 = arith.constant -57376585569545145944295328828381171477604071846055643819493376494671449030656 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) @@ -263,62 +290,93 @@ contract C { // CHECK-NEXT: %11 = arith.subi %9, %6 : i256 loc(#loc6) // CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc6) // CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %13 = arith.addi %5, %c68_i256 : i256 loc(#loc6) -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc7) -// CHECK-NEXT: %16 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc7) -// CHECK-NEXT: %18 = arith.addi %5, %c32_i256 : i256 loc(#loc7) -// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %21 = "llvm.intrcall"(%15, %2, %19, %17, %20, %c0_i256) <{id = 4090 : i32, name = "evm.staticcall"}> : (i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc7) -// CHECK-NEXT: %22 = arith.cmpi ne, %21, %c0_i256 : i256 loc(#loc7) -// CHECK-NEXT: %23 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc7) -// CHECK-NEXT: %24 = arith.addi %23, %c31_i256 : i256 loc(#loc7) -// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc7) -// CHECK-NEXT: %26 = arith.addi %25, %c32_i256 : i256 loc(#loc7) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc7) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc7) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: llvm.store %23, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc7) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc7) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %23) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc7) -// CHECK-NEXT: %35 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc8) -// CHECK-NEXT: llvm.store %22, %35 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc8) -// CHECK-NEXT: %36 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc8) -// CHECK-NEXT: llvm.store %28, %36 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc8) -// CHECK-NEXT: %37 = llvm.load %35 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc9) -// CHECK-NEXT: %38 = arith.cmpi eq, %37, %false : i1 loc(#loc9) -// CHECK-NEXT: cf.cond_br %38, ^bb1, ^bb2 loc(#loc10) +// CHECK-NEXT: %13 = arith.addi %5, %c96_i256 : i256 loc(#loc6) +// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc6) +// CHECK-NEXT: %15 = arith.cmpi ult, %13, %5 : i256 loc(#loc6) +// CHECK-NEXT: %16 = arith.ori %14, %15 : i1 loc(#loc6) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc6) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc6) +// CHECK-NEXT: } loc(#loc6) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %13, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %18 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc7) +// CHECK-NEXT: %19 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc7) +// CHECK-NEXT: %21 = arith.addi %5, %c32_i256 : i256 loc(#loc7) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %24 = "llvm.intrcall"(%18, %2, %22, %20, %23, %c0_i256) <{id = 4090 : i32, name = "evm.staticcall"}> : (i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc7) +// CHECK-NEXT: %25 = arith.cmpi ne, %24, %c0_i256 : i256 loc(#loc7) +// CHECK-NEXT: %26 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc7) +// CHECK-NEXT: %27 = arith.addi %26, %c31_i256 : i256 loc(#loc7) +// CHECK-NEXT: %28 = arith.andi %27, %c-32_i256 : i256 loc(#loc7) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc7) +// CHECK-NEXT: %31 = arith.addi %28, %c63_i256 : i256 loc(#loc7) +// CHECK-NEXT: %32 = arith.andi %31, %c-32_i256 : i256 loc(#loc7) +// CHECK-NEXT: %33 = arith.addi %30, %32 : i256 loc(#loc7) +// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %c18446744073709551615_i256 : i256 loc(#loc7) +// CHECK-NEXT: %35 = arith.cmpi ult, %33, %30 : i256 loc(#loc7) +// CHECK-NEXT: %36 = arith.ori %34, %35 : i1 loc(#loc7) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc7) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc7) +// CHECK-NEXT: } loc(#loc7) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %33, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %38 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %26, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %39 = arith.addi %30, %c32_i256 : i256 loc(#loc7) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc7) +// CHECK-NEXT: "llvm.intr.memcpy"(%40, %41, %26) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc7) +// CHECK-NEXT: %42 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc8) +// CHECK-NEXT: llvm.store %25, %42 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc8) +// CHECK-NEXT: %43 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc8) +// CHECK-NEXT: llvm.store %30, %43 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc8) +// CHECK-NEXT: %44 = llvm.load %42 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc9) +// CHECK-NEXT: %45 = arith.cmpi eq, %44, %false : i1 loc(#loc9) +// CHECK-NEXT: cf.cond_br %45, ^bb1, ^bb2 loc(#loc10) // CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: return %false, %c0_i256 : i1, i256 loc(#loc11) // CHECK-NEXT: ^bb2: // pred: ^bb0 -// CHECK-NEXT: %39 = llvm.load %36 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc12) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc13) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc13) -// CHECK-NEXT: %42 = arith.addi %39, %c32_i256 : i256 loc(#loc13) -// CHECK-NEXT: %43 = arith.cmpi slt, %41, %c32_i256 : i256 loc(#loc13) -// CHECK-NEXT: scf.if %43 { -// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc13) -// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc13) +// CHECK-NEXT: %46 = llvm.load %43 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc12) +// CHECK-NEXT: %47 = arith.addi %46, %c32_i256 : i256 loc(#loc13) +// CHECK-NEXT: %48 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc13) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc13) +// CHECK-NEXT: %50 = arith.cmpi slt, %49, %c32_i256 : i256 loc(#loc13) +// CHECK-NEXT: scf.if %50 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc13) +// CHECK-NEXT: "llvm.intrcall"(%53, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc13) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc13) // CHECK-NEXT: } loc(#loc13) -// CHECK-NEXT: %44 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc13) -// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc13) -// CHECK-NEXT: return %true, %45 : i1, i256 loc(#loc14) +// CHECK-NEXT: %51 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc13) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc13) +// CHECK-NEXT: return %true, %52 : i1, i256 loc(#loc14) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: func.func @delegatecall_100(%arg0: i256 loc({{.*}}:15:24)) -> (i1, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c-57376585569545145944295328828381171477604071846055643819493376494671449030656_i256 = arith.constant -57376585569545145944295328828381171477604071846055643819493376494671449030656 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) @@ -343,62 +401,93 @@ contract C { // CHECK-NEXT: %11 = arith.subi %9, %6 : i256 loc(#loc19) // CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc19) // CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: %13 = arith.addi %5, %c68_i256 : i256 loc(#loc19) -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc20) -// CHECK-NEXT: %16 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %18 = arith.addi %5, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %21 = "llvm.intrcall"(%15, %2, %19, %17, %20, %c0_i256) <{id = 4048 : i32, name = "evm.delegatecall"}> : (i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc20) -// CHECK-NEXT: %22 = arith.cmpi ne, %21, %c0_i256 : i256 loc(#loc20) -// CHECK-NEXT: %23 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc20) -// CHECK-NEXT: %24 = arith.addi %23, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %26 = arith.addi %25, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc20) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %23, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc20) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %23) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc20) -// CHECK-NEXT: %35 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc21) -// CHECK-NEXT: llvm.store %22, %35 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc21) -// CHECK-NEXT: %36 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc21) -// CHECK-NEXT: llvm.store %28, %36 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc21) -// CHECK-NEXT: %37 = llvm.load %35 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc22) -// CHECK-NEXT: %38 = arith.cmpi eq, %37, %false : i1 loc(#loc22) -// CHECK-NEXT: cf.cond_br %38, ^bb1, ^bb2 loc(#loc23) +// CHECK-NEXT: %13 = arith.addi %5, %c96_i256 : i256 loc(#loc19) +// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc19) +// CHECK-NEXT: %15 = arith.cmpi ult, %13, %5 : i256 loc(#loc19) +// CHECK-NEXT: %16 = arith.ori %14, %15 : i1 loc(#loc19) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc19) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %13, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %18 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc20) +// CHECK-NEXT: %19 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %21 = arith.addi %5, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %24 = "llvm.intrcall"(%18, %2, %22, %20, %23, %c0_i256) <{id = 4048 : i32, name = "evm.delegatecall"}> : (i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc20) +// CHECK-NEXT: %25 = arith.cmpi ne, %24, %c0_i256 : i256 loc(#loc20) +// CHECK-NEXT: %26 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc20) +// CHECK-NEXT: %27 = arith.addi %26, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %28 = arith.andi %27, %c-32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %31 = arith.addi %28, %c63_i256 : i256 loc(#loc20) +// CHECK-NEXT: %32 = arith.andi %31, %c-32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %33 = arith.addi %30, %32 : i256 loc(#loc20) +// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %c18446744073709551615_i256 : i256 loc(#loc20) +// CHECK-NEXT: %35 = arith.cmpi ult, %33, %30 : i256 loc(#loc20) +// CHECK-NEXT: %36 = arith.ori %34, %35 : i1 loc(#loc20) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %33, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %38 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %26, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %39 = arith.addi %30, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc20) +// CHECK-NEXT: "llvm.intr.memcpy"(%40, %41, %26) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc20) +// CHECK-NEXT: %42 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc21) +// CHECK-NEXT: llvm.store %25, %42 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc21) +// CHECK-NEXT: %43 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc21) +// CHECK-NEXT: llvm.store %30, %43 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc21) +// CHECK-NEXT: %44 = llvm.load %42 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc22) +// CHECK-NEXT: %45 = arith.cmpi eq, %44, %false : i1 loc(#loc22) +// CHECK-NEXT: cf.cond_br %45, ^bb1, ^bb2 loc(#loc23) // CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: return %false, %c0_i256 : i1, i256 loc(#loc24) // CHECK-NEXT: ^bb2: // pred: ^bb0 -// CHECK-NEXT: %39 = llvm.load %36 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc25) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: %42 = arith.addi %39, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: %43 = arith.cmpi slt, %41, %c32_i256 : i256 loc(#loc26) -// CHECK-NEXT: scf.if %43 { -// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc26) +// CHECK-NEXT: %46 = llvm.load %43 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc25) +// CHECK-NEXT: %47 = arith.addi %46, %c32_i256 : i256 loc(#loc26) +// CHECK-NEXT: %48 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) +// CHECK-NEXT: %50 = arith.cmpi slt, %49, %c32_i256 : i256 loc(#loc26) +// CHECK-NEXT: scf.if %50 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: "llvm.intrcall"(%53, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc26) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc26) // CHECK-NEXT: } loc(#loc26) -// CHECK-NEXT: %44 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc26) -// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) -// CHECK-NEXT: return %true, %45 : i1, i256 loc(#loc27) +// CHECK-NEXT: %51 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc26) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc26) +// CHECK-NEXT: return %true, %52 : i1, i256 loc(#loc27) // CHECK-NEXT: } loc(#loc15) // CHECK-NEXT: func.func @call_56(%arg0: i256 loc({{.*}}:7:16)) -> (i1, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c-57376585569545145944295328828381171477604071846055643819493376494671449030656_i256 = arith.constant -57376585569545145944295328828381171477604071846055643819493376494671449030656 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) @@ -423,55 +512,80 @@ contract C { // CHECK-NEXT: %11 = arith.subi %9, %6 : i256 loc(#loc32) // CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc32) // CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) -// CHECK-NEXT: %13 = arith.addi %5, %c68_i256 : i256 loc(#loc32) -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc32) -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc33) -// CHECK-NEXT: %16 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc33) -// CHECK-NEXT: %18 = arith.addi %5, %c32_i256 : i256 loc(#loc33) -// CHECK-NEXT: %19 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %21 = "llvm.intrcall"(%15, %2, %c0_i256, %19, %17, %20, %c0_i256) <{id = 4035 : i32, name = "evm.call"}> : (i256, i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc33) -// CHECK-NEXT: %22 = arith.cmpi ne, %21, %c0_i256 : i256 loc(#loc33) -// CHECK-NEXT: %23 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc33) -// CHECK-NEXT: %24 = arith.addi %23, %c31_i256 : i256 loc(#loc33) -// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc33) -// CHECK-NEXT: %26 = arith.addi %25, %c32_i256 : i256 loc(#loc33) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc33) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc33) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: llvm.store %23, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc33) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc33) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc33) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %23) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc33) -// CHECK-NEXT: %35 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc34) -// CHECK-NEXT: llvm.store %22, %35 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc34) -// CHECK-NEXT: %36 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc34) -// CHECK-NEXT: llvm.store %28, %36 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc34) -// CHECK-NEXT: %37 = llvm.load %35 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc35) -// CHECK-NEXT: %38 = arith.cmpi eq, %37, %false : i1 loc(#loc35) -// CHECK-NEXT: cf.cond_br %38, ^bb1, ^bb2 loc(#loc36) +// CHECK-NEXT: %13 = arith.addi %5, %c96_i256 : i256 loc(#loc32) +// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc32) +// CHECK-NEXT: %15 = arith.cmpi ult, %13, %5 : i256 loc(#loc32) +// CHECK-NEXT: %16 = arith.ori %14, %15 : i1 loc(#loc32) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc32) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc32) +// CHECK-NEXT: } loc(#loc32) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: llvm.store %13, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc32) +// CHECK-NEXT: %18 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc33) +// CHECK-NEXT: %19 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc33) +// CHECK-NEXT: %21 = arith.addi %5, %c32_i256 : i256 loc(#loc33) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %24 = "llvm.intrcall"(%18, %2, %c0_i256, %22, %20, %23, %c0_i256) <{id = 4035 : i32, name = "evm.call"}> : (i256, i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc33) +// CHECK-NEXT: %25 = arith.cmpi ne, %24, %c0_i256 : i256 loc(#loc33) +// CHECK-NEXT: %26 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc33) +// CHECK-NEXT: %27 = arith.addi %26, %c31_i256 : i256 loc(#loc33) +// CHECK-NEXT: %28 = arith.andi %27, %c-32_i256 : i256 loc(#loc33) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc33) +// CHECK-NEXT: %31 = arith.addi %28, %c63_i256 : i256 loc(#loc33) +// CHECK-NEXT: %32 = arith.andi %31, %c-32_i256 : i256 loc(#loc33) +// CHECK-NEXT: %33 = arith.addi %30, %32 : i256 loc(#loc33) +// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %c18446744073709551615_i256 : i256 loc(#loc33) +// CHECK-NEXT: %35 = arith.cmpi ult, %33, %30 : i256 loc(#loc33) +// CHECK-NEXT: %36 = arith.ori %34, %35 : i1 loc(#loc33) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %54 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %c65_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: "llvm.intrcall"(%55, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc33) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc33) +// CHECK-NEXT: } loc(#loc33) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %33, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %38 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: llvm.store %26, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %39 = arith.addi %30, %c32_i256 : i256 loc(#loc33) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc33) +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc33) +// CHECK-NEXT: "llvm.intr.memcpy"(%40, %41, %26) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc33) +// CHECK-NEXT: %42 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc34) +// CHECK-NEXT: llvm.store %25, %42 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc34) +// CHECK-NEXT: %43 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc34) +// CHECK-NEXT: llvm.store %30, %43 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc34) +// CHECK-NEXT: %44 = llvm.load %42 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc35) +// CHECK-NEXT: %45 = arith.cmpi eq, %44, %false : i1 loc(#loc35) +// CHECK-NEXT: cf.cond_br %45, ^bb1, ^bb2 loc(#loc36) // CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: return %false, %c0_i256 : i1, i256 loc(#loc37) // CHECK-NEXT: ^bb2: // pred: ^bb0 -// CHECK-NEXT: %39 = llvm.load %36 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc38) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %42 = arith.addi %39, %c32_i256 : i256 loc(#loc39) -// CHECK-NEXT: %43 = arith.cmpi slt, %41, %c32_i256 : i256 loc(#loc39) -// CHECK-NEXT: scf.if %43 { -// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) +// CHECK-NEXT: %46 = llvm.load %43 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc38) +// CHECK-NEXT: %47 = arith.addi %46, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %48 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %49 = llvm.load %48 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: %50 = arith.cmpi slt, %49, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: scf.if %50 { +// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: "llvm.intrcall"(%53, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) // CHECK-NEXT: } loc(#loc39) -// CHECK-NEXT: %44 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: return %true, %45 : i1, i256 loc(#loc40) +// CHECK-NEXT: %51 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) +// CHECK-NEXT: return %true, %52 : i1, i256 loc(#loc40) // CHECK-NEXT: } loc(#loc28) // CHECK-NEXT: func.func @inc_12(%arg0: i256 loc({{.*}}:3:15)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/bool-cleanup.sol b/test/lit/mlirCodegen/EVM/bool-cleanup.sol index 2884c0e67..876e825f8 100644 --- a/test/lit/mlirCodegen/EVM/bool-cleanup.sol +++ b/test/lit/mlirCodegen/EVM/bool-cleanup.sol @@ -39,6 +39,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -47,8 +54,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_81"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -56,22 +63,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_81() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_81_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_81_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_81_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_81_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -83,6 +104,7 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) @@ -90,9 +112,9 @@ contract C { // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) @@ -126,63 +148,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -192,73 +214,86 @@ contract C { // CHECK-NEXT: %22 = arith.addi %20, %21 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.muli %19, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.index_castui %19 : i256 to index loc(#loc1) -// CHECK-NEXT: %34:2 = scf.for %arg0 = %c0 to %33 step %c1 iter_args(%arg1 = %32, %arg2 = %20) -> (i256, i256) { -// CHECK-NEXT: %41 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.cmpi ne, %42, %c0_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = arith.extui %43 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.cmpi ne, %42, %44 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %45 { -// CHECK-NEXT: %50 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%50, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.index_castui %19 : i256 to index loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg0 = %c0 to %37 step %c1 iter_args(%arg1 = %36, %arg2 = %20) -> (i256, i256) { +// CHECK-NEXT: %45 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.cmpi ne, %46, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.extui %47 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %49 = arith.cmpi ne, %46, %48 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %49 { +// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%54, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %46 = arith.extui %43 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %46, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %48, %49 : i256, i256 loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = func.call @mem_bool_18(%28) : (i256) -> i1 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.extui %35 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%40, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %50 = arith.extui %47 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %50, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %52, %53 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %39 = func.call @mem_bool_18(%27) : (i256) -> i1 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.extui %39 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %42, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%44, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -304,63 +339,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -370,86 +405,102 @@ contract C { // CHECK-NEXT: %22 = arith.addi %20, %21 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.muli %19, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.index_castui %19 : i256 to index loc(#loc1) -// CHECK-NEXT: %34:2 = scf.for %arg0 = %c0 to %33 step %c1 iter_args(%arg1 = %32, %arg2 = %20) -> (i256, i256) { -// CHECK-NEXT: %52 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = arith.cmpi ne, %53, %c0_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = arith.extui %54 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %56 = arith.cmpi ne, %53, %55 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %56 { -// CHECK-NEXT: %61 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%61, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.index_castui %19 : i256 to index loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg0 = %c0 to %37 step %c1 iter_args(%arg1 = %36, %arg2 = %20) -> (i256, i256) { +// CHECK-NEXT: %58 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %60 = arith.cmpi ne, %59, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: %61 = arith.extui %60 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.cmpi ne, %59, %61 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %62 { +// CHECK-NEXT: %67 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %57 = arith.extui %54 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %59, %60 : i256, i256 loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = func.call @encode_array_bool_50(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %37, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%44, %45, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %42, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %42, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %48 = arith.andi %47, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %40, %48 : i256 loc(#loc1) -// CHECK-NEXT: %50 = arith.subi %49, %37 : i256 loc(#loc1) -// CHECK-NEXT: %51 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%51, %50) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %63 = arith.extui %60 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %63, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %65, %66 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %39 = func.call @encode_array_bool_50(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %41, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %41, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %39, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%48, %49, %46) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %44, %46 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %46, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %46, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.andi %53, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %44, %54 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.subi %55, %41 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %56) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -457,63 +508,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -523,86 +574,102 @@ contract C { // CHECK-NEXT: %22 = arith.addi %20, %21 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %53, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %53, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %53, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %53, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %59, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = llvm.inttoptr %53 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%63, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %59, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %59, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %59, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.muli %19, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %52 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.index_castui %19 : i256 to index loc(#loc1) -// CHECK-NEXT: %34:2 = scf.for %arg0 = %c0 to %33 step %c1 iter_args(%arg1 = %32, %arg2 = %20) -> (i256, i256) { -// CHECK-NEXT: %52 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %54 = arith.cmpi ne, %53, %c0_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = arith.extui %54 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %56 = arith.cmpi ne, %53, %55 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %56 { -// CHECK-NEXT: %61 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%61, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %58 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.index_castui %19 : i256 to index loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg0 = %c0 to %37 step %c1 iter_args(%arg1 = %36, %arg2 = %20) -> (i256, i256) { +// CHECK-NEXT: %58 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %59 = llvm.load %58 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %60 = arith.cmpi ne, %59, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: %61 = arith.extui %60 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.cmpi ne, %59, %61 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %62 { +// CHECK-NEXT: %67 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%67, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %57 = arith.extui %54 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %59, %60 : i256, i256 loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = func.call @encode_packed_array_bool_64(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %37, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%44, %45, %42) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %42, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %42, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %48 = arith.andi %47, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %40, %48 : i256 loc(#loc1) -// CHECK-NEXT: %50 = arith.subi %49, %37 : i256 loc(#loc1) -// CHECK-NEXT: %51 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%51, %50) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %63 = arith.extui %60 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %63, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %65, %66 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %39 = func.call @encode_packed_array_bool_64(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %41, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %41, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %39, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%48, %49, %46) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %44, %46 : i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %46, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %46, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.andi %53, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %44, %54 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.subi %55, %41 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %56) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -610,63 +677,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -675,61 +742,74 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %44, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %44, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %44, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %48, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = arith.addi %44, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %48, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %48, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %48, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%58, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%49, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @decode_bool_80(%28) : (i256) -> i1 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %40 = arith.extui %37 : i1 to i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%49, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @decode_bool_80(%27) : (i256) -> i1 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = arith.extui %41 : i1 to i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %44, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c32_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -749,16 +829,16 @@ contract C { // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc3) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc3) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc4) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc5) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc5) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc5) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc5) // CHECK-NEXT: scf.if %5 { // CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc5) // CHECK-NEXT: "llvm.intrcall"(%11, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc5) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc5) // CHECK-NEXT: } loc(#loc5) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc5) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc5) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc5) // CHECK-NEXT: %8 = arith.cmpi ne, %7, %c0_i256 : i256 loc(#loc5) // CHECK-NEXT: %9 = arith.extui %8 : i1 to i256 loc(#loc5) @@ -771,6 +851,13 @@ contract C { // CHECK-NEXT: return %8 : i1 loc(#loc6) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: func.func @encode_packed_array_bool_64(%arg0: i256 loc({{.*}}:22:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) @@ -787,26 +874,50 @@ contract C { // CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) // CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc10) // CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) -// CHECK-NEXT: %15 = arith.cmpi ne, %14, %c0_i256 : i256 loc(#loc10) -// CHECK-NEXT: %16 = arith.extui %15 : i1 to i256 loc(#loc10) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc10) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc10) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) +// CHECK-NEXT: %23 = arith.cmpi ne, %22, %c0_i256 : i256 loc(#loc10) +// CHECK-NEXT: %24 = arith.extui %23 : i1 to i256 loc(#loc10) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc10) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc10) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc10) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc10) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc10) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) // CHECK-NEXT: } loc(#loc10) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc10) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) // CHECK-NEXT: return %3 : i256 loc(#loc11) // CHECK-NEXT: } loc(#loc7) // CHECK-NEXT: func.func @encode_array_bool_50(%arg0: i256 loc({{.*}}:18:29)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) @@ -833,21 +944,37 @@ contract C { // CHECK-NEXT: %14 = arith.muli %9, %c32_i256 : i256 loc(#loc15) // CHECK-NEXT: %15 = arith.addi %12, %14 : i256 loc(#loc15) // CHECK-NEXT: %16:2 = scf.for %arg1 = %c0 to %11 step %c1 iter_args(%arg2 = %12, %arg3 = %13) -> (i256, i256) { -// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: %22 = arith.cmpi ne, %21, %c0_i256 : i256 loc(#loc15) -// CHECK-NEXT: %23 = arith.extui %22 : i1 to i256 loc(#loc15) -// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc15) +// CHECK-NEXT: %27 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: %29 = arith.cmpi ne, %28, %c0_i256 : i256 loc(#loc15) +// CHECK-NEXT: %30 = arith.extui %29 : i1 to i256 loc(#loc15) +// CHECK-NEXT: %31 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %32 = arith.addi %arg2, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %33 = arith.addi %arg3, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc15) // CHECK-NEXT: } loc(#loc15) // CHECK-NEXT: %17 = arith.subi %15, %4 : i256 loc(#loc15) // CHECK-NEXT: %18 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc15) // CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %19 = arith.subi %15, %3 : i256 loc(#loc15) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc15) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %22 = arith.addi %3, %21 : i256 loc(#loc15) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %3 : i256 loc(#loc15) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc15) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) // CHECK-NEXT: return %3 : i256 loc(#loc16) // CHECK-NEXT: } loc(#loc12) // CHECK-NEXT: func.func @storage_array_bool_36() -> i1 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { diff --git a/test/lit/mlirCodegen/EVM/bool-storage.sol b/test/lit/mlirCodegen/EVM/bool-storage.sol index 2febd3670..178f6aa66 100644 --- a/test/lit/mlirCodegen/EVM/bool-storage.sol +++ b/test/lit/mlirCodegen/EVM/bool-storage.sol @@ -33,6 +33,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -41,8 +48,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_54"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -50,22 +57,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_54() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_54_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_54_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_54_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_54_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/bytes.sol b/test/lit/mlirCodegen/EVM/bytes.sol index 07ee0610c..22c8bc6f0 100644 --- a/test/lit/mlirCodegen/EVM/bytes.sol +++ b/test/lit/mlirCodegen/EVM/bytes.sol @@ -24,6 +24,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -32,8 +39,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_41"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -41,22 +48,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_41() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_41_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_41_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_41_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_41_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/calldata-bytes.sol b/test/lit/mlirCodegen/EVM/calldata-bytes.sol index 54f746f12..f02fa8875 100644 --- a/test/lit/mlirCodegen/EVM/calldata-bytes.sol +++ b/test/lit/mlirCodegen/EVM/calldata-bytes.sol @@ -13,6 +13,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -21,8 +28,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_12"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -30,22 +37,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_12() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_12_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_12_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_12_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_12_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/code.sol b/test/lit/mlirCodegen/EVM/code.sol index 99caa781b..adb41bdc8 100644 --- a/test/lit/mlirCodegen/EVM/code.sol +++ b/test/lit/mlirCodegen/EVM/code.sol @@ -23,6 +23,13 @@ contract D { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -31,8 +38,8 @@ contract D { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -40,22 +47,36 @@ contract D { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_9() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_9_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_9_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -127,6 +148,13 @@ contract D { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -135,8 +163,8 @@ contract D { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_55"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -144,22 +172,36 @@ contract D { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @D_55() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_55_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_55_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_55_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_55_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -193,8 +235,8 @@ contract D { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = func.call @g_34() : () -> i256 loc(#loc1) @@ -210,14 +252,17 @@ contract D { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -282,6 +327,12 @@ contract D { // CHECK-NEXT: return %12 : i256 loc(#loc7) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: func.func @g_34() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) @@ -300,14 +351,14 @@ contract D { // CHECK-NEXT: %7 = "llvm.intrcall"(%c0_i256, %6, %3) <{id = 4044 : i32, name = "evm.create"}> : (i256, !llvm.ptr<1>, i256) -> i256 loc(#loc9) // CHECK-NEXT: %8 = arith.cmpi eq, %7, %c0_i256 : i256 loc(#loc9) // CHECK-NEXT: scf.if %8 { -// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc9) -// CHECK-NEXT: %28 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc9) -// CHECK-NEXT: %29 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc9) -// CHECK-NEXT: "llvm.intr.memcpy"(%29, %30, %28) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc9) -// CHECK-NEXT: %31 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: "llvm.intrcall"(%31, %28) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc9) +// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %31 = llvm.load %30 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc9) +// CHECK-NEXT: %32 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc9) +// CHECK-NEXT: %33 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc9) +// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %32) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc9) +// CHECK-NEXT: %35 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: "llvm.intrcall"(%35, %32) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc9) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc9) // CHECK-NEXT: } loc(#loc9) // CHECK-NEXT: %9 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc10) @@ -320,19 +371,32 @@ contract D { // CHECK-NEXT: %14 = "llvm.intrcall"(%13) <{id = 4054 : i32, name = "evm.extcodesize"}> : (i256) -> i256 loc(#loc14) // CHECK-NEXT: %15 = arith.addi %14, %c31_i256 : i256 loc(#loc14) // CHECK-NEXT: %16 = arith.andi %15, %c-32_i256 : i256 loc(#loc14) -// CHECK-NEXT: %17 = arith.addi %16, %c32_i256 : i256 loc(#loc14) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc14) -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc14) -// CHECK-NEXT: %20 = arith.addi %19, %17 : i256 loc(#loc14) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc14) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) -// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc14) -// CHECK-NEXT: llvm.store %14, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) -// CHECK-NEXT: %23 = arith.addi %19, %c32_i256 : i256 loc(#loc14) -// CHECK-NEXT: %24 = llvm.inttoptr %23 : i256 to !llvm.ptr<1> loc(#loc14) -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<4> loc(#loc14) -// CHECK-NEXT: "llvm.intrcall"(%13, %24, %25, %14) <{id = 4052 : i32, name = "evm.extcodecopy"}> : (i256, !llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc14) -// CHECK-NEXT: return %19 : i256 loc(#loc15) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc14) +// CHECK-NEXT: %19 = arith.addi %16, %c63_i256 : i256 loc(#loc14) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc14) +// CHECK-NEXT: %21 = arith.addi %18, %20 : i256 loc(#loc14) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc14) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %18 : i256 loc(#loc14) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc14) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc14) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc14) +// CHECK-NEXT: } loc(#loc14) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %26 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: llvm.store %14, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %27 = arith.addi %18, %c32_i256 : i256 loc(#loc14) +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc14) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<4> loc(#loc14) +// CHECK-NEXT: "llvm.intrcall"(%13, %28, %29, %14) <{id = 4052 : i32, name = "evm.extcodecopy"}> : (i256, !llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc14) +// CHECK-NEXT: return %18 : i256 loc(#loc15) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/concat.sol b/test/lit/mlirCodegen/EVM/concat.sol index bbdca5cd0..04592a9f6 100644 --- a/test/lit/mlirCodegen/EVM/concat.sol +++ b/test/lit/mlirCodegen/EVM/concat.sol @@ -109,12 +109,12 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: #loc5 = loc({{.*}}:4:18) // CHECK-NEXT: #loc7 = loc({{.*}}:6:12) // CHECK-NEXT: #loc8 = loc({{.*}}:6:28) -// CHECK-NEXT: #loc14 = loc({{.*}}:10:12) -// CHECK-NEXT: #loc15 = loc({{.*}}:10:30) -// CHECK-NEXT: #loc21 = loc({{.*}}:14:12) -// CHECK-NEXT: #loc22 = loc({{.*}}:14:23) -// CHECK-NEXT: #loc28 = loc({{.*}}:18:12) -// CHECK-NEXT: #loc29 = loc({{.*}}:18:29) +// CHECK-NEXT: #loc13 = loc({{.*}}:10:12) +// CHECK-NEXT: #loc14 = loc({{.*}}:10:30) +// CHECK-NEXT: #loc20 = loc({{.*}}:14:12) +// CHECK-NEXT: #loc21 = loc({{.*}}:14:23) +// CHECK-NEXT: #loc27 = loc({{.*}}:18:12) +// CHECK-NEXT: #loc28 = loc({{.*}}:18:29) // CHECK-NEXT: #loc34 = loc({{.*}}:22:13) // CHECK-NEXT: #loc35 = loc({{.*}}:22:29) // CHECK-NEXT: #loc41 = loc({{.*}}:26:13) @@ -169,6 +169,12 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: return loc(#loc4) // CHECK-NEXT: } loc(#loc4) // CHECK-NEXT: func.func @fa_29(%arg0: i256 loc({{.*}}:6:12), %arg1: i256 loc({{.*}}:6:28)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -180,106 +186,156 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc8) // CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc9) // CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc10) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc11) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc11) -// CHECK-NEXT: %9 = arith.addi %2, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %10 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: "llvm.intr.memmove"(%10, %11, %8) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc11) -// CHECK-NEXT: %12 = arith.addi %6, %8 : i256 loc(#loc11) -// CHECK-NEXT: %13 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc11) -// CHECK-NEXT: %15 = arith.addi %3, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %16 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: "llvm.intr.memmove"(%16, %17, %14) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc11) -// CHECK-NEXT: %18 = arith.addi %12, %14 : i256 loc(#loc11) -// CHECK-NEXT: %19 = arith.subi %18, %6 : i256 loc(#loc11) -// CHECK-NEXT: %20 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %21 = arith.subi %18, %5 : i256 loc(#loc11) -// CHECK-NEXT: %22 = arith.addi %21, %c31_i256 : i256 loc(#loc11) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %24 = arith.addi %5, %23 : i256 loc(#loc11) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc12) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.addi %2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%10, %11, %8) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %12 = arith.addi %6, %8 : i256 loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %15 = arith.addi %3, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%16, %17, %14) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %18 = arith.addi %12, %14 : i256 loc(#loc1) +// CHECK-NEXT: %19 = arith.subi %18, %6 : i256 loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %21 = arith.subi %18, %5 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.addi %21, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %5, %23 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.cmpi ult, %24, %5 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.ori %25, %26 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %27 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%31, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %24, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc11) // CHECK-NEXT: return loc(#loc6) // CHECK-NEXT: } loc(#loc6) // CHECK-NEXT: func.func @fb_46(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:10:12), %arg1: !llvm.struct<(i256, i256)> loc({{.*}}:10:30)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc14) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc14) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc15) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc15) -// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc16) -// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc17) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc18) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc18) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc18) -// CHECK-NEXT: %7 = llvm.extractvalue %2[1] : !llvm.struct<(i256, i256)> loc(#loc18) -// CHECK-NEXT: %8 = llvm.extractvalue %2[0] : !llvm.struct<(i256, i256)> loc(#loc18) -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc18) -// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<2> loc(#loc18) -// CHECK-NEXT: "llvm.intr.memcpy"(%9, %10, %7) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc18) -// CHECK-NEXT: %11 = arith.addi %6, %7 : i256 loc(#loc18) -// CHECK-NEXT: %12 = llvm.extractvalue %3[1] : !llvm.struct<(i256, i256)> loc(#loc18) -// CHECK-NEXT: %13 = llvm.extractvalue %3[0] : !llvm.struct<(i256, i256)> loc(#loc18) -// CHECK-NEXT: %14 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc18) -// CHECK-NEXT: %15 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc18) -// CHECK-NEXT: "llvm.intr.memcpy"(%14, %15, %12) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc18) -// CHECK-NEXT: %16 = arith.addi %11, %12 : i256 loc(#loc18) -// CHECK-NEXT: %17 = arith.subi %16, %6 : i256 loc(#loc18) -// CHECK-NEXT: %18 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc18) -// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc18) -// CHECK-NEXT: %19 = arith.subi %16, %5 : i256 loc(#loc18) -// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc18) -// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc18) -// CHECK-NEXT: %22 = arith.addi %5, %21 : i256 loc(#loc18) -// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc18) -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc18) -// CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc19) -// CHECK-NEXT: return loc(#loc13) -// CHECK-NEXT: } loc(#loc13) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc13) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc13) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc14) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc14) +// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc15) +// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc16) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc17) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc17) +// CHECK-NEXT: %7 = llvm.extractvalue %2[1] : !llvm.struct<(i256, i256)> loc(#loc17) +// CHECK-NEXT: %8 = llvm.extractvalue %2[0] : !llvm.struct<(i256, i256)> loc(#loc17) +// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<2> loc(#loc17) +// CHECK-NEXT: "llvm.intr.memcpy"(%9, %10, %7) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc17) +// CHECK-NEXT: %11 = arith.addi %6, %7 : i256 loc(#loc17) +// CHECK-NEXT: %12 = llvm.extractvalue %3[1] : !llvm.struct<(i256, i256)> loc(#loc17) +// CHECK-NEXT: %13 = llvm.extractvalue %3[0] : !llvm.struct<(i256, i256)> loc(#loc17) +// CHECK-NEXT: %14 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %15 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc17) +// CHECK-NEXT: "llvm.intr.memcpy"(%14, %15, %12) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc17) +// CHECK-NEXT: %16 = arith.addi %11, %12 : i256 loc(#loc17) +// CHECK-NEXT: %17 = arith.subi %16, %6 : i256 loc(#loc17) +// CHECK-NEXT: %18 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %19 = arith.subi %16, %5 : i256 loc(#loc17) +// CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc17) +// CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc17) +// CHECK-NEXT: %22 = arith.addi %5, %21 : i256 loc(#loc17) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc17) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %5 : i256 loc(#loc17) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc17) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc17) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc17) +// CHECK-NEXT: } loc(#loc17) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc18) +// CHECK-NEXT: return loc(#loc12) +// CHECK-NEXT: } loc(#loc12) // CHECK-NEXT: func.func @fc_63(%arg0: i256 loc({{.*}}:14:12), %arg1: i256 loc({{.*}}:14:23)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c79_i256 = arith.constant 79 : i256 loc(#loc) // CHECK-NEXT: %c48_i256 = arith.constant 48 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc21) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc21) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc22) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc22) -// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc23) -// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc24) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc25) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc25) -// CHECK-NEXT: %7 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %8 = arith.addi %5, %c48_i256 : i256 loc(#loc25) -// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %3, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %10 = arith.addi %5, %c79_i256 : i256 loc(#loc25) -// CHECK-NEXT: %11 = arith.subi %10, %6 : i256 loc(#loc25) -// CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: %13 = arith.addi %5, %c96_i256 : i256 loc(#loc25) -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc25) -// CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc26) -// CHECK-NEXT: return loc(#loc20) -// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc20) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc20) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc21) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc21) +// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc22) +// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc23) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc24) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc24) +// CHECK-NEXT: %7 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %8 = arith.addi %5, %c48_i256 : i256 loc(#loc24) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %3, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %10 = arith.addi %5, %c79_i256 : i256 loc(#loc24) +// CHECK-NEXT: %11 = arith.subi %10, %6 : i256 loc(#loc24) +// CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %13 = arith.addi %5, %c96_i256 : i256 loc(#loc24) +// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc24) +// CHECK-NEXT: %15 = arith.cmpi ult, %13, %5 : i256 loc(#loc24) +// CHECK-NEXT: %16 = arith.ori %14, %15 : i1 loc(#loc24) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %19 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %c65_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: "llvm.intrcall"(%20, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc24) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc24) +// CHECK-NEXT: } loc(#loc24) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: llvm.store %13, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc24) +// CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc25) +// CHECK-NEXT: return loc(#loc19) +// CHECK-NEXT: } loc(#loc19) // CHECK-NEXT: func.func @fd_80(%arg0: i256 loc({{.*}}:18:12), %arg1: i256 loc({{.*}}:18:29)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -294,114 +350,132 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc28) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc28) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc29) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc29) -// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc30) -// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc31) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<5> loc(#loc1) -// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc1) -// CHECK-NEXT: %9 = arith.shrui %8, %c1_i256 : i256 loc(#loc1) -// CHECK-NEXT: %10 = arith.andi %8, %c1_i256 : i256 loc(#loc1) -// CHECK-NEXT: %11 = arith.cmpi eq, %10, %c0_i256 : i256 loc(#loc1) -// CHECK-NEXT: %12 = arith.andi %9, %c127_i256 : i256 loc(#loc1) -// CHECK-NEXT: %13 = arith.select %11, %12, %9 : i256 loc(#loc1) -// CHECK-NEXT: %14 = arith.cmpi ult, %13, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %15 = arith.trunci %10 : i256 to i1 loc(#loc1) -// CHECK-NEXT: %16 = arith.cmpi eq, %15, %14 : i1 loc(#loc1) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc27) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc27) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc28) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc28) +// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc29) +// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc30) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %7 = llvm.inttoptr %2 : i256 to !llvm.ptr<5> loc(#loc31) +// CHECK-NEXT: %8 = llvm.load %7 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc31) +// CHECK-NEXT: %9 = arith.shrui %8, %c1_i256 : i256 loc(#loc31) +// CHECK-NEXT: %10 = arith.andi %8, %c1_i256 : i256 loc(#loc31) +// CHECK-NEXT: %11 = arith.cmpi eq, %10, %c0_i256 : i256 loc(#loc31) +// CHECK-NEXT: %12 = arith.andi %9, %c127_i256 : i256 loc(#loc31) +// CHECK-NEXT: %13 = arith.select %11, %12, %9 : i256 loc(#loc31) +// CHECK-NEXT: %14 = arith.cmpi ult, %13, %c32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %15 = arith.trunci %10 : i256 to i1 loc(#loc31) +// CHECK-NEXT: %16 = arith.cmpi eq, %15, %14 : i1 loc(#loc31) // CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %17 = arith.andi %8, %c1_i256 : i256 loc(#loc1) -// CHECK-NEXT: %18 = arith.cmpi eq, %17, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c34_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc31) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %17 = arith.andi %8, %c1_i256 : i256 loc(#loc31) +// CHECK-NEXT: %18 = arith.cmpi eq, %17, %c0_i256 : i256 loc(#loc31) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %40 = arith.andi %8, %c-256_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = arith.andi %8, %c-256_i256 : i256 loc(#loc31) +// CHECK-NEXT: %44 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) // CHECK-NEXT: } else { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %2, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = "llvm.intrcall"(%41, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.index_castui %13 : i256 to index loc(#loc1) -// CHECK-NEXT: scf.for %arg2 = %c0 to %43 step %c32 { -// CHECK-NEXT: %44 = arith.index_castui %arg2 : index to i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.divui %44, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %45 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<5> loc(#loc1) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %6, %44 : i256 loc(#loc1) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %48, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %19 = arith.addi %6, %13 : i256 loc(#loc1) -// CHECK-NEXT: %20 = llvm.inttoptr %3 : i256 to !llvm.ptr<5> loc(#loc1) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc1) -// CHECK-NEXT: %22 = arith.shrui %21, %c1_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %21, %c1_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.cmpi eq, %23, %c0_i256 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.andi %22, %c127_i256 : i256 loc(#loc1) -// CHECK-NEXT: %26 = arith.select %24, %25, %22 : i256 loc(#loc1) -// CHECK-NEXT: %27 = arith.cmpi ult, %26, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %28 = arith.trunci %23 : i256 to i1 loc(#loc1) -// CHECK-NEXT: %29 = arith.cmpi eq, %28, %27 : i1 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %2, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %45 = "llvm.intrcall"(%44, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc31) +// CHECK-NEXT: %46 = arith.index_castui %13 : i256 to index loc(#loc31) +// CHECK-NEXT: scf.for %arg2 = %c0 to %46 step %c32 { +// CHECK-NEXT: %47 = arith.index_castui %arg2 : index to i256 loc(#loc31) +// CHECK-NEXT: %48 = arith.divui %47, %c32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %49 = arith.addi %45, %48 : i256 loc(#loc31) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<5> loc(#loc31) +// CHECK-NEXT: %51 = llvm.load %50 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc31) +// CHECK-NEXT: %52 = arith.addi %6, %47 : i256 loc(#loc31) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %51, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %19 = arith.addi %6, %13 : i256 loc(#loc31) +// CHECK-NEXT: %20 = llvm.inttoptr %3 : i256 to !llvm.ptr<5> loc(#loc31) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc31) +// CHECK-NEXT: %22 = arith.shrui %21, %c1_i256 : i256 loc(#loc31) +// CHECK-NEXT: %23 = arith.andi %21, %c1_i256 : i256 loc(#loc31) +// CHECK-NEXT: %24 = arith.cmpi eq, %23, %c0_i256 : i256 loc(#loc31) +// CHECK-NEXT: %25 = arith.andi %22, %c127_i256 : i256 loc(#loc31) +// CHECK-NEXT: %26 = arith.select %24, %25, %22 : i256 loc(#loc31) +// CHECK-NEXT: %27 = arith.cmpi ult, %26, %c32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %28 = arith.trunci %23 : i256 to i1 loc(#loc31) +// CHECK-NEXT: %29 = arith.cmpi eq, %28, %27 : i1 loc(#loc31) // CHECK-NEXT: scf.if %29 { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%42, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %30 = arith.andi %21, %c1_i256 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.cmpi eq, %30, %c0_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c34_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc31) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %30 = arith.andi %21, %c1_i256 : i256 loc(#loc31) +// CHECK-NEXT: %31 = arith.cmpi eq, %30, %c0_i256 : i256 loc(#loc31) // CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %40 = arith.andi %21, %c-256_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = arith.andi %21, %c-256_i256 : i256 loc(#loc31) +// CHECK-NEXT: %44 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) // CHECK-NEXT: } else { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %3, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = "llvm.intrcall"(%41, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.index_castui %26 : i256 to index loc(#loc1) -// CHECK-NEXT: scf.for %arg2 = %c0 to %43 step %c32 { -// CHECK-NEXT: %44 = arith.index_castui %arg2 : index to i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.divui %44, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %45 : i256 loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<5> loc(#loc1) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %19, %44 : i256 loc(#loc1) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %48, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %19, %26 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.subi %32, %6 : i256 loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = arith.subi %32, %5 : i256 loc(#loc1) -// CHECK-NEXT: %36 = arith.addi %35, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %37 = arith.andi %36, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %5, %37 : i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %3, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %45 = "llvm.intrcall"(%44, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc31) +// CHECK-NEXT: %46 = arith.index_castui %26 : i256 to index loc(#loc31) +// CHECK-NEXT: scf.for %arg2 = %c0 to %46 step %c32 { +// CHECK-NEXT: %47 = arith.index_castui %arg2 : index to i256 loc(#loc31) +// CHECK-NEXT: %48 = arith.divui %47, %c32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %49 = arith.addi %45, %48 : i256 loc(#loc31) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<5> loc(#loc31) +// CHECK-NEXT: %51 = llvm.load %50 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc31) +// CHECK-NEXT: %52 = arith.addi %19, %47 : i256 loc(#loc31) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %51, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %32 = arith.addi %19, %26 : i256 loc(#loc31) +// CHECK-NEXT: %33 = arith.subi %32, %6 : i256 loc(#loc31) +// CHECK-NEXT: %34 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %35 = arith.subi %32, %5 : i256 loc(#loc31) +// CHECK-NEXT: %36 = arith.addi %35, %c31_i256 : i256 loc(#loc31) +// CHECK-NEXT: %37 = arith.andi %36, %c-32_i256 : i256 loc(#loc31) +// CHECK-NEXT: %38 = arith.addi %5, %37 : i256 loc(#loc31) +// CHECK-NEXT: %39 = arith.cmpi ugt, %38, %c18446744073709551615_i256 : i256 loc(#loc31) +// CHECK-NEXT: %40 = arith.cmpi ult, %38, %5 : i256 loc(#loc31) +// CHECK-NEXT: %41 = arith.ori %39, %40 : i1 loc(#loc31) +// CHECK-NEXT: scf.if %41 { +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c65_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc31) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %38, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc32) -// CHECK-NEXT: return loc(#loc27) -// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: return loc(#loc26) +// CHECK-NEXT: } loc(#loc26) // CHECK-NEXT: func.func @fab_97(%arg0: i256 loc({{.*}}:22:13), %arg1: !llvm.struct<(i256, i256)> loc({{.*}}:22:29)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -436,12 +510,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %21 = arith.addi %20, %c31_i256 : i256 loc(#loc38) // CHECK-NEXT: %22 = arith.andi %21, %c-32_i256 : i256 loc(#loc38) // CHECK-NEXT: %23 = arith.addi %5, %22 : i256 loc(#loc38) -// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %c18446744073709551615_i256 : i256 loc(#loc38) +// CHECK-NEXT: %25 = arith.cmpi ult, %23, %5 : i256 loc(#loc38) +// CHECK-NEXT: %26 = arith.ori %24, %25 : i1 loc(#loc38) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %29 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %c65_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: "llvm.intrcall"(%30, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc38) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc38) +// CHECK-NEXT: } loc(#loc38) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc38) +// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc38) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc39) // CHECK-NEXT: return loc(#loc33) // CHECK-NEXT: } loc(#loc33) // CHECK-NEXT: func.func @fac_114(%arg0: i256 loc({{.*}}:26:13), %arg1: i256 loc({{.*}}:26:29)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c5_i256 = arith.constant 5 : i256 loc(#loc) @@ -474,12 +566,26 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %18 = arith.addi %17, %c31_i256 : i256 loc(#loc45) // CHECK-NEXT: %19 = arith.andi %18, %c-32_i256 : i256 loc(#loc45) // CHECK-NEXT: %20 = arith.addi %5, %19 : i256 loc(#loc45) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc45) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %5 : i256 loc(#loc45) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc45) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %26 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %c65_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: "llvm.intrcall"(%27, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc45) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc45) +// CHECK-NEXT: } loc(#loc45) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc45) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc45) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc46) // CHECK-NEXT: return loc(#loc40) // CHECK-NEXT: } loc(#loc40) // CHECK-NEXT: func.func @fad_131(%arg0: i256 loc({{.*}}:30:13), %arg1: i256 loc({{.*}}:30:29)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -521,35 +627,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %21 = arith.trunci %16 : i256 to i1 loc(#loc52) // CHECK-NEXT: %22 = arith.cmpi eq, %21, %20 : i1 loc(#loc52) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: %34 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: llvm.store %c34_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: "llvm.intrcall"(%35, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc52) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %37 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %c34_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: "llvm.intrcall"(%38, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc52) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc52) // CHECK-NEXT: } loc(#loc52) // CHECK-NEXT: %23 = arith.andi %14, %c1_i256 : i256 loc(#loc52) // CHECK-NEXT: %24 = arith.cmpi eq, %23, %c0_i256 : i256 loc(#loc52) // CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %33 = arith.andi %14, %c-256_i256 : i256 loc(#loc52) -// CHECK-NEXT: %34 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %36 = arith.andi %14, %c-256_i256 : i256 loc(#loc52) +// CHECK-NEXT: %37 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %36, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) // CHECK-NEXT: } else { -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: llvm.store %3, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: %35 = "llvm.intrcall"(%34, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc52) -// CHECK-NEXT: %36 = arith.index_castui %19 : i256 to index loc(#loc52) -// CHECK-NEXT: scf.for %arg2 = %c0 to %36 step %c32 { -// CHECK-NEXT: %37 = arith.index_castui %arg2 : index to i256 loc(#loc52) -// CHECK-NEXT: %38 = arith.divui %37, %c32_i256 : i256 loc(#loc52) -// CHECK-NEXT: %39 = arith.addi %35, %38 : i256 loc(#loc52) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<5> loc(#loc52) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc52) -// CHECK-NEXT: %42 = arith.addi %12, %37 : i256 loc(#loc52) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: llvm.store %41, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %3, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %38 = "llvm.intrcall"(%37, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc52) +// CHECK-NEXT: %39 = arith.index_castui %19 : i256 to index loc(#loc52) +// CHECK-NEXT: scf.for %arg2 = %c0 to %39 step %c32 { +// CHECK-NEXT: %40 = arith.index_castui %arg2 : index to i256 loc(#loc52) +// CHECK-NEXT: %41 = arith.divui %40, %c32_i256 : i256 loc(#loc52) +// CHECK-NEXT: %42 = arith.addi %38, %41 : i256 loc(#loc52) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<5> loc(#loc52) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc52) +// CHECK-NEXT: %45 = arith.addi %12, %40 : i256 loc(#loc52) +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %44, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) // CHECK-NEXT: } loc(#loc52) // CHECK-NEXT: } loc(#loc52) // CHECK-NEXT: %25 = arith.addi %12, %19 : i256 loc(#loc52) @@ -560,12 +666,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %29 = arith.addi %28, %c31_i256 : i256 loc(#loc52) // CHECK-NEXT: %30 = arith.andi %29, %c-32_i256 : i256 loc(#loc52) // CHECK-NEXT: %31 = arith.addi %5, %30 : i256 loc(#loc52) -// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc52) -// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc52) +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %5 : i256 loc(#loc52) +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 loc(#loc52) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %37 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %c65_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: "llvm.intrcall"(%38, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc52) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc52) +// CHECK-NEXT: } loc(#loc52) +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc52) +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc52) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc53) // CHECK-NEXT: return loc(#loc47) // CHECK-NEXT: } loc(#loc47) // CHECK-NEXT: func.func @fba_148(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:34:13), %arg1: i256 loc({{.*}}:34:31)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -600,12 +724,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %21 = arith.addi %20, %c31_i256 : i256 loc(#loc59) // CHECK-NEXT: %22 = arith.andi %21, %c-32_i256 : i256 loc(#loc59) // CHECK-NEXT: %23 = arith.addi %5, %22 : i256 loc(#loc59) -// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc59) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %c18446744073709551615_i256 : i256 loc(#loc59) +// CHECK-NEXT: %25 = arith.cmpi ult, %23, %5 : i256 loc(#loc59) +// CHECK-NEXT: %26 = arith.ori %24, %25 : i1 loc(#loc59) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %29 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %c65_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: "llvm.intrcall"(%30, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc59) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc59) +// CHECK-NEXT: } loc(#loc59) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc60) // CHECK-NEXT: return loc(#loc54) // CHECK-NEXT: } loc(#loc54) // CHECK-NEXT: func.func @fbc_165(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:38:13), %arg1: i256 loc({{.*}}:38:31)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c7_i256 = arith.constant 7 : i256 loc(#loc) @@ -637,12 +779,26 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %17 = arith.addi %16, %c31_i256 : i256 loc(#loc66) // CHECK-NEXT: %18 = arith.andi %17, %c-32_i256 : i256 loc(#loc66) // CHECK-NEXT: %19 = arith.addi %5, %18 : i256 loc(#loc66) -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc66) -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc66) +// CHECK-NEXT: %20 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc66) +// CHECK-NEXT: %21 = arith.cmpi ult, %19, %5 : i256 loc(#loc66) +// CHECK-NEXT: %22 = arith.ori %20, %21 : i1 loc(#loc66) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc66) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc66) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc66) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc66) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc66) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc66) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc66) +// CHECK-NEXT: } loc(#loc66) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc66) +// CHECK-NEXT: llvm.store %19, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc66) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc67) // CHECK-NEXT: return loc(#loc61) // CHECK-NEXT: } loc(#loc61) // CHECK-NEXT: func.func @fbd_182(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:42:13), %arg1: i256 loc({{.*}}:42:31)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -683,35 +839,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %20 = arith.trunci %15 : i256 to i1 loc(#loc73) // CHECK-NEXT: %21 = arith.cmpi eq, %20, %19 : i1 loc(#loc73) // CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: llvm.store %c34_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc73) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %36 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: "llvm.intrcall"(%37, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc73) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc73) // CHECK-NEXT: } loc(#loc73) // CHECK-NEXT: %22 = arith.andi %13, %c1_i256 : i256 loc(#loc73) // CHECK-NEXT: %23 = arith.cmpi eq, %22, %c0_i256 : i256 loc(#loc73) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %32 = arith.andi %13, %c-256_i256 : i256 loc(#loc73) -// CHECK-NEXT: %33 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %35 = arith.andi %13, %c-256_i256 : i256 loc(#loc73) +// CHECK-NEXT: %36 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) // CHECK-NEXT: } else { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: llvm.store %3, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: %34 = "llvm.intrcall"(%33, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc73) -// CHECK-NEXT: %35 = arith.index_castui %18 : i256 to index loc(#loc73) -// CHECK-NEXT: scf.for %arg2 = %c0 to %35 step %c32 { -// CHECK-NEXT: %36 = arith.index_castui %arg2 : index to i256 loc(#loc73) -// CHECK-NEXT: %37 = arith.divui %36, %c32_i256 : i256 loc(#loc73) -// CHECK-NEXT: %38 = arith.addi %34, %37 : i256 loc(#loc73) -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<5> loc(#loc73) -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc73) -// CHECK-NEXT: %41 = arith.addi %11, %36 : i256 loc(#loc73) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: llvm.store %40, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %3, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %37 = "llvm.intrcall"(%36, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc73) +// CHECK-NEXT: %38 = arith.index_castui %18 : i256 to index loc(#loc73) +// CHECK-NEXT: scf.for %arg2 = %c0 to %38 step %c32 { +// CHECK-NEXT: %39 = arith.index_castui %arg2 : index to i256 loc(#loc73) +// CHECK-NEXT: %40 = arith.divui %39, %c32_i256 : i256 loc(#loc73) +// CHECK-NEXT: %41 = arith.addi %37, %40 : i256 loc(#loc73) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<5> loc(#loc73) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc73) +// CHECK-NEXT: %44 = arith.addi %11, %39 : i256 loc(#loc73) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %43, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) // CHECK-NEXT: } loc(#loc73) // CHECK-NEXT: } loc(#loc73) // CHECK-NEXT: %24 = arith.addi %11, %18 : i256 loc(#loc73) @@ -722,13 +878,27 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %28 = arith.addi %27, %c31_i256 : i256 loc(#loc73) // CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc73) // CHECK-NEXT: %30 = arith.addi %5, %29 : i256 loc(#loc73) -// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc73) -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc73) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %5 : i256 loc(#loc73) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc73) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %36 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c65_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: "llvm.intrcall"(%37, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc73) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc73) +// CHECK-NEXT: } loc(#loc73) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc74) // CHECK-NEXT: return loc(#loc68) // CHECK-NEXT: } loc(#loc68) // CHECK-NEXT: func.func @fcd_199(%arg0: i256 loc({{.*}}:46:13), %arg1: i256 loc({{.*}}:46:24)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c48_i256 = arith.constant 48 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -766,35 +936,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %17 = arith.trunci %12 : i256 to i1 loc(#loc80) // CHECK-NEXT: %18 = arith.cmpi eq, %17, %16 : i1 loc(#loc80) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: %30 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: llvm.store %c34_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: "llvm.intrcall"(%31, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc80) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %c34_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc80) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc80) // CHECK-NEXT: } loc(#loc80) // CHECK-NEXT: %19 = arith.andi %10, %c1_i256 : i256 loc(#loc80) // CHECK-NEXT: %20 = arith.cmpi eq, %19, %c0_i256 : i256 loc(#loc80) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %29 = arith.andi %10, %c-256_i256 : i256 loc(#loc80) -// CHECK-NEXT: %30 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %32 = arith.andi %10, %c-256_i256 : i256 loc(#loc80) +// CHECK-NEXT: %33 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) // CHECK-NEXT: } else { -// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: llvm.store %3, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: %31 = "llvm.intrcall"(%30, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc80) -// CHECK-NEXT: %32 = arith.index_castui %15 : i256 to index loc(#loc80) -// CHECK-NEXT: scf.for %arg2 = %c0 to %32 step %c32 { -// CHECK-NEXT: %33 = arith.index_castui %arg2 : index to i256 loc(#loc80) -// CHECK-NEXT: %34 = arith.divui %33, %c32_i256 : i256 loc(#loc80) -// CHECK-NEXT: %35 = arith.addi %31, %34 : i256 loc(#loc80) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<5> loc(#loc80) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc80) -// CHECK-NEXT: %38 = arith.addi %8, %33 : i256 loc(#loc80) -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: llvm.store %37, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %3, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %34 = "llvm.intrcall"(%33, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc80) +// CHECK-NEXT: %35 = arith.index_castui %15 : i256 to index loc(#loc80) +// CHECK-NEXT: scf.for %arg2 = %c0 to %35 step %c32 { +// CHECK-NEXT: %36 = arith.index_castui %arg2 : index to i256 loc(#loc80) +// CHECK-NEXT: %37 = arith.divui %36, %c32_i256 : i256 loc(#loc80) +// CHECK-NEXT: %38 = arith.addi %34, %37 : i256 loc(#loc80) +// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<5> loc(#loc80) +// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc80) +// CHECK-NEXT: %41 = arith.addi %8, %36 : i256 loc(#loc80) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %40, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) // CHECK-NEXT: } loc(#loc80) // CHECK-NEXT: } loc(#loc80) // CHECK-NEXT: %21 = arith.addi %8, %15 : i256 loc(#loc80) @@ -805,12 +975,26 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %25 = arith.addi %24, %c31_i256 : i256 loc(#loc80) // CHECK-NEXT: %26 = arith.andi %25, %c-32_i256 : i256 loc(#loc80) // CHECK-NEXT: %27 = arith.addi %5, %26 : i256 loc(#loc80) -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc80) -// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %28 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc80) +// CHECK-NEXT: %29 = arith.cmpi ult, %27, %5 : i256 loc(#loc80) +// CHECK-NEXT: %30 = arith.ori %28, %29 : i1 loc(#loc80) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %c65_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc80) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc80) +// CHECK-NEXT: } loc(#loc80) +// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc80) +// CHECK-NEXT: llvm.store %27, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc80) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc81) // CHECK-NEXT: return loc(#loc75) // CHECK-NEXT: } loc(#loc75) // CHECK-NEXT: func.func @fda_216(%arg0: i256 loc({{.*}}:50:13), %arg1: i256 loc({{.*}}:50:30)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -845,35 +1029,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %15 = arith.trunci %10 : i256 to i1 loc(#loc87) // CHECK-NEXT: %16 = arith.cmpi eq, %15, %14 : i1 loc(#loc87) // CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: %34 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: llvm.store %c34_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: "llvm.intrcall"(%35, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc87) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %37 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %c34_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: "llvm.intrcall"(%38, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc87) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc87) // CHECK-NEXT: } loc(#loc87) // CHECK-NEXT: %17 = arith.andi %8, %c1_i256 : i256 loc(#loc87) // CHECK-NEXT: %18 = arith.cmpi eq, %17, %c0_i256 : i256 loc(#loc87) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %33 = arith.andi %8, %c-256_i256 : i256 loc(#loc87) -// CHECK-NEXT: %34 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %36 = arith.andi %8, %c-256_i256 : i256 loc(#loc87) +// CHECK-NEXT: %37 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %36, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) // CHECK-NEXT: } else { -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: llvm.store %2, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: %35 = "llvm.intrcall"(%34, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc87) -// CHECK-NEXT: %36 = arith.index_castui %13 : i256 to index loc(#loc87) -// CHECK-NEXT: scf.for %arg2 = %c0 to %36 step %c32 { -// CHECK-NEXT: %37 = arith.index_castui %arg2 : index to i256 loc(#loc87) -// CHECK-NEXT: %38 = arith.divui %37, %c32_i256 : i256 loc(#loc87) -// CHECK-NEXT: %39 = arith.addi %35, %38 : i256 loc(#loc87) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<5> loc(#loc87) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc87) -// CHECK-NEXT: %42 = arith.addi %6, %37 : i256 loc(#loc87) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: llvm.store %41, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %2, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %38 = "llvm.intrcall"(%37, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc87) +// CHECK-NEXT: %39 = arith.index_castui %13 : i256 to index loc(#loc87) +// CHECK-NEXT: scf.for %arg2 = %c0 to %39 step %c32 { +// CHECK-NEXT: %40 = arith.index_castui %arg2 : index to i256 loc(#loc87) +// CHECK-NEXT: %41 = arith.divui %40, %c32_i256 : i256 loc(#loc87) +// CHECK-NEXT: %42 = arith.addi %38, %41 : i256 loc(#loc87) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<5> loc(#loc87) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc87) +// CHECK-NEXT: %45 = arith.addi %6, %40 : i256 loc(#loc87) +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %44, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) // CHECK-NEXT: } loc(#loc87) // CHECK-NEXT: } loc(#loc87) // CHECK-NEXT: %19 = arith.addi %6, %13 : i256 loc(#loc87) @@ -891,12 +1075,26 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %29 = arith.addi %28, %c31_i256 : i256 loc(#loc87) // CHECK-NEXT: %30 = arith.andi %29, %c-32_i256 : i256 loc(#loc87) // CHECK-NEXT: %31 = arith.addi %5, %30 : i256 loc(#loc87) -// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc87) -// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc87) +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %5 : i256 loc(#loc87) +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 loc(#loc87) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %37 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %c65_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: "llvm.intrcall"(%38, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc87) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc87) +// CHECK-NEXT: } loc(#loc87) +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc87) +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc87) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc88) // CHECK-NEXT: return loc(#loc82) // CHECK-NEXT: } loc(#loc82) // CHECK-NEXT: func.func @fdb_233(%arg0: i256 loc({{.*}}:54:13), %arg1: !llvm.struct<(i256, i256)> loc({{.*}}:54:30)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -931,35 +1129,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %15 = arith.trunci %10 : i256 to i1 loc(#loc94) // CHECK-NEXT: %16 = arith.cmpi eq, %15, %14 : i1 loc(#loc94) // CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: llvm.store %c34_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc94) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %36 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %c34_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: "llvm.intrcall"(%37, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc94) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc94) // CHECK-NEXT: } loc(#loc94) // CHECK-NEXT: %17 = arith.andi %8, %c1_i256 : i256 loc(#loc94) // CHECK-NEXT: %18 = arith.cmpi eq, %17, %c0_i256 : i256 loc(#loc94) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %32 = arith.andi %8, %c-256_i256 : i256 loc(#loc94) -// CHECK-NEXT: %33 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %35 = arith.andi %8, %c-256_i256 : i256 loc(#loc94) +// CHECK-NEXT: %36 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) // CHECK-NEXT: } else { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: llvm.store %2, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: %34 = "llvm.intrcall"(%33, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc94) -// CHECK-NEXT: %35 = arith.index_castui %13 : i256 to index loc(#loc94) -// CHECK-NEXT: scf.for %arg2 = %c0 to %35 step %c32 { -// CHECK-NEXT: %36 = arith.index_castui %arg2 : index to i256 loc(#loc94) -// CHECK-NEXT: %37 = arith.divui %36, %c32_i256 : i256 loc(#loc94) -// CHECK-NEXT: %38 = arith.addi %34, %37 : i256 loc(#loc94) -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<5> loc(#loc94) -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc94) -// CHECK-NEXT: %41 = arith.addi %6, %36 : i256 loc(#loc94) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: llvm.store %40, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %2, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %37 = "llvm.intrcall"(%36, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc94) +// CHECK-NEXT: %38 = arith.index_castui %13 : i256 to index loc(#loc94) +// CHECK-NEXT: scf.for %arg2 = %c0 to %38 step %c32 { +// CHECK-NEXT: %39 = arith.index_castui %arg2 : index to i256 loc(#loc94) +// CHECK-NEXT: %40 = arith.divui %39, %c32_i256 : i256 loc(#loc94) +// CHECK-NEXT: %41 = arith.addi %37, %40 : i256 loc(#loc94) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<5> loc(#loc94) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc94) +// CHECK-NEXT: %44 = arith.addi %6, %39 : i256 loc(#loc94) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %43, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) // CHECK-NEXT: } loc(#loc94) // CHECK-NEXT: } loc(#loc94) // CHECK-NEXT: %19 = arith.addi %6, %13 : i256 loc(#loc94) @@ -976,13 +1174,31 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %28 = arith.addi %27, %c31_i256 : i256 loc(#loc94) // CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc94) // CHECK-NEXT: %30 = arith.addi %5, %29 : i256 loc(#loc94) -// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc94) -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc94) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %5 : i256 loc(#loc94) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc94) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %36 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %c65_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: "llvm.intrcall"(%37, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc94) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc94) +// CHECK-NEXT: } loc(#loc94) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc94) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc95) // CHECK-NEXT: return loc(#loc89) // CHECK-NEXT: } loc(#loc89) // CHECK-NEXT: func.func @fdc_250(%arg0: i256 loc({{.*}}:58:13), %arg1: i256 loc({{.*}}:58:23)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1014,12 +1230,26 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %18 = arith.addi %17, %c31_i256 : i256 loc(#loc101) // CHECK-NEXT: %19 = arith.andi %18, %c-32_i256 : i256 loc(#loc101) // CHECK-NEXT: %20 = arith.addi %5, %19 : i256 loc(#loc101) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc101) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc101) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc101) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %5 : i256 loc(#loc101) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc101) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc101) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc101) +// CHECK-NEXT: %26 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc101) +// CHECK-NEXT: llvm.store %c65_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc101) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc101) +// CHECK-NEXT: "llvm.intrcall"(%27, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc101) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc101) +// CHECK-NEXT: } loc(#loc101) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc101) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc101) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc102) // CHECK-NEXT: return loc(#loc96) // CHECK-NEXT: } loc(#loc96) // CHECK-NEXT: func.func @fds_267(%arg0: i256 loc({{.*}}:62:13), %arg1: i256 loc({{.*}}:62:30)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c8_i256 = arith.constant 8 : i256 loc(#loc) @@ -1055,35 +1285,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %15 = arith.trunci %10 : i256 to i1 loc(#loc108) // CHECK-NEXT: %16 = arith.cmpi eq, %15, %14 : i1 loc(#loc108) // CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: %30 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: llvm.store %c34_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: "llvm.intrcall"(%31, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc108) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %c34_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc108) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc108) // CHECK-NEXT: } loc(#loc108) // CHECK-NEXT: %17 = arith.andi %8, %c1_i256 : i256 loc(#loc108) // CHECK-NEXT: %18 = arith.cmpi eq, %17, %c0_i256 : i256 loc(#loc108) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %29 = arith.andi %8, %c-256_i256 : i256 loc(#loc108) -// CHECK-NEXT: %30 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %32 = arith.andi %8, %c-256_i256 : i256 loc(#loc108) +// CHECK-NEXT: %33 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) // CHECK-NEXT: } else { -// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: llvm.store %2, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: %31 = "llvm.intrcall"(%30, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc108) -// CHECK-NEXT: %32 = arith.index_castui %13 : i256 to index loc(#loc108) -// CHECK-NEXT: scf.for %arg2 = %c0 to %32 step %c32 { -// CHECK-NEXT: %33 = arith.index_castui %arg2 : index to i256 loc(#loc108) -// CHECK-NEXT: %34 = arith.divui %33, %c32_i256 : i256 loc(#loc108) -// CHECK-NEXT: %35 = arith.addi %31, %34 : i256 loc(#loc108) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<5> loc(#loc108) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc108) -// CHECK-NEXT: %38 = arith.addi %6, %33 : i256 loc(#loc108) -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: llvm.store %37, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %2, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %34 = "llvm.intrcall"(%33, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc108) +// CHECK-NEXT: %35 = arith.index_castui %13 : i256 to index loc(#loc108) +// CHECK-NEXT: scf.for %arg2 = %c0 to %35 step %c32 { +// CHECK-NEXT: %36 = arith.index_castui %arg2 : index to i256 loc(#loc108) +// CHECK-NEXT: %37 = arith.divui %36, %c32_i256 : i256 loc(#loc108) +// CHECK-NEXT: %38 = arith.addi %34, %37 : i256 loc(#loc108) +// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<5> loc(#loc108) +// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc108) +// CHECK-NEXT: %41 = arith.addi %6, %36 : i256 loc(#loc108) +// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %40, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) // CHECK-NEXT: } loc(#loc108) // CHECK-NEXT: } loc(#loc108) // CHECK-NEXT: %19 = arith.addi %6, %13 : i256 loc(#loc108) @@ -1097,26 +1327,61 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %25 = arith.addi %24, %c31_i256 : i256 loc(#loc108) // CHECK-NEXT: %26 = arith.andi %25, %c-32_i256 : i256 loc(#loc108) // CHECK-NEXT: %27 = arith.addi %5, %26 : i256 loc(#loc108) -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc108) -// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %28 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc108) +// CHECK-NEXT: %29 = arith.cmpi ult, %27, %5 : i256 loc(#loc108) +// CHECK-NEXT: %30 = arith.ori %28, %29 : i1 loc(#loc108) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %c65_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc108) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc108) +// CHECK-NEXT: } loc(#loc108) +// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc108) +// CHECK-NEXT: llvm.store %27, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc108) // CHECK-NEXT: call @f_bytes_6(%5) : (i256) -> () loc(#loc109) // CHECK-NEXT: return loc(#loc103) // CHECK-NEXT: } loc(#loc103) // CHECK-NEXT: func.func @f0_278() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc111) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc111) // CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc111) // CHECK-NEXT: llvm.store %c0_i256, %2 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc111) // CHECK-NEXT: %3 = arith.addi %1, %c32_i256 : i256 loc(#loc111) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc111) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc111) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc111) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %1 : i256 loc(#loc111) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc111) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %8 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc111) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc111) +// CHECK-NEXT: %9 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc111) +// CHECK-NEXT: llvm.store %c65_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc111) +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc111) +// CHECK-NEXT: "llvm.intrcall"(%10, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc111) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc111) +// CHECK-NEXT: } loc(#loc111) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc111) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc111) // CHECK-NEXT: call @f_bytes_6(%1) : (i256) -> () loc(#loc112) // CHECK-NEXT: return loc(#loc110) // CHECK-NEXT: } loc(#loc110) // CHECK-NEXT: func.func @f1a_292(%arg0: i256 loc({{.*}}:70:13)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1141,12 +1406,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc116) // CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc116) // CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc116) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc116) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc116) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc116) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc116) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc116) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc116) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc116) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc116) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc116) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc116) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc116) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc116) +// CHECK-NEXT: } loc(#loc116) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc116) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc116) // CHECK-NEXT: call @f_bytes_6(%3) : (i256) -> () loc(#loc117) // CHECK-NEXT: return loc(#loc113) // CHECK-NEXT: } loc(#loc113) // CHECK-NEXT: func.func @f1b_306(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:74:13)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1170,13 +1453,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %12 = arith.addi %11, %c31_i256 : i256 loc(#loc121) // CHECK-NEXT: %13 = arith.andi %12, %c-32_i256 : i256 loc(#loc121) // CHECK-NEXT: %14 = arith.addi %3, %13 : i256 loc(#loc121) -// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc121) -// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc121) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc121) +// CHECK-NEXT: %16 = arith.cmpi ult, %14, %3 : i256 loc(#loc121) +// CHECK-NEXT: %17 = arith.ori %15, %16 : i1 loc(#loc121) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc121) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc121) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc121) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc121) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc121) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc121) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc121) +// CHECK-NEXT: } loc(#loc121) +// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc121) +// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc121) // CHECK-NEXT: call @f_bytes_6(%3) : (i256) -> () loc(#loc122) // CHECK-NEXT: return loc(#loc118) // CHECK-NEXT: } loc(#loc118) // CHECK-NEXT: func.func @f1c_320(%arg0: i256 loc({{.*}}:78:13)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc124) @@ -1193,12 +1493,26 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc126) // CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc126) // CHECK-NEXT: %9 = arith.addi %3, %c64_i256 : i256 loc(#loc126) -// CHECK-NEXT: %10 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc126) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc126) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc126) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %3 : i256 loc(#loc126) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc126) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc126) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc126) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc126) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc126) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc126) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc126) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc126) +// CHECK-NEXT: } loc(#loc126) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc126) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc126) // CHECK-NEXT: call @f_bytes_6(%3) : (i256) -> () loc(#loc127) // CHECK-NEXT: return loc(#loc123) // CHECK-NEXT: } loc(#loc123) // CHECK-NEXT: func.func @f1d_334(%arg0: i256 loc({{.*}}:82:13)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -1230,35 +1544,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %13 = arith.trunci %8 : i256 to i1 loc(#loc131) // CHECK-NEXT: %14 = arith.cmpi eq, %13, %12 : i1 loc(#loc131) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: llvm.store %c34_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc131) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %c34_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc131) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc131) // CHECK-NEXT: } loc(#loc131) // CHECK-NEXT: %15 = arith.andi %6, %c1_i256 : i256 loc(#loc131) // CHECK-NEXT: %16 = arith.cmpi eq, %15, %c0_i256 : i256 loc(#loc131) // CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %24 = arith.andi %6, %c-256_i256 : i256 loc(#loc131) -// CHECK-NEXT: %25 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %27 = arith.andi %6, %c-256_i256 : i256 loc(#loc131) +// CHECK-NEXT: %28 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) // CHECK-NEXT: } else { -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: llvm.store %1, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: %26 = "llvm.intrcall"(%25, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc131) -// CHECK-NEXT: %27 = arith.index_castui %11 : i256 to index loc(#loc131) -// CHECK-NEXT: scf.for %arg1 = %c0 to %27 step %c32 { -// CHECK-NEXT: %28 = arith.index_castui %arg1 : index to i256 loc(#loc131) -// CHECK-NEXT: %29 = arith.divui %28, %c32_i256 : i256 loc(#loc131) -// CHECK-NEXT: %30 = arith.addi %26, %29 : i256 loc(#loc131) -// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<5> loc(#loc131) -// CHECK-NEXT: %32 = llvm.load %31 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc131) -// CHECK-NEXT: %33 = arith.addi %4, %28 : i256 loc(#loc131) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: llvm.store %32, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %1, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %29 = "llvm.intrcall"(%28, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc131) +// CHECK-NEXT: %30 = arith.index_castui %11 : i256 to index loc(#loc131) +// CHECK-NEXT: scf.for %arg1 = %c0 to %30 step %c32 { +// CHECK-NEXT: %31 = arith.index_castui %arg1 : index to i256 loc(#loc131) +// CHECK-NEXT: %32 = arith.divui %31, %c32_i256 : i256 loc(#loc131) +// CHECK-NEXT: %33 = arith.addi %29, %32 : i256 loc(#loc131) +// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<5> loc(#loc131) +// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc131) +// CHECK-NEXT: %36 = arith.addi %4, %31 : i256 loc(#loc131) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %35, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) // CHECK-NEXT: } loc(#loc131) // CHECK-NEXT: } loc(#loc131) // CHECK-NEXT: %17 = arith.addi %4, %11 : i256 loc(#loc131) @@ -1268,12 +1582,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc131) // CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc131) // CHECK-NEXT: %22 = arith.addi %3, %21 : i256 loc(#loc131) -// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc131) -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc131) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %3 : i256 loc(#loc131) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc131) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc131) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc131) +// CHECK-NEXT: } loc(#loc131) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc131) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc131) // CHECK-NEXT: call @f_bytes_6(%3) : (i256) -> () loc(#loc132) // CHECK-NEXT: return loc(#loc128) // CHECK-NEXT: } loc(#loc128) // CHECK-NEXT: func.func @f3_354(%arg0: i256 loc({{.*}}:86:12), %arg1: !llvm.struct<(i256, i256)> loc({{.*}}:86:28), %arg2: i256 loc({{.*}}:86:46)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c16_i256 = arith.constant 16 : i256 loc(#loc) @@ -1315,12 +1647,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %25 = arith.addi %24, %c31_i256 : i256 loc(#loc140) // CHECK-NEXT: %26 = arith.andi %25, %c-32_i256 : i256 loc(#loc140) // CHECK-NEXT: %27 = arith.addi %7, %26 : i256 loc(#loc140) -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %28 = arith.cmpi ugt, %27, %c18446744073709551615_i256 : i256 loc(#loc140) +// CHECK-NEXT: %29 = arith.cmpi ult, %27, %7 : i256 loc(#loc140) +// CHECK-NEXT: %30 = arith.ori %28, %29 : i1 loc(#loc140) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %c65_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc140) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc140) +// CHECK-NEXT: } loc(#loc140) +// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %27, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) // CHECK-NEXT: call @f_bytes_6(%7) : (i256) -> () loc(#loc141) // CHECK-NEXT: return loc(#loc133) // CHECK-NEXT: } loc(#loc133) // CHECK-NEXT: func.func @fstr_aa_371(%arg0: i256 loc({{.*}}:90:17), %arg1: i256 loc({{.*}}:90:34)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1356,12 +1706,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %22 = arith.addi %21, %c31_i256 : i256 loc(#loc147) // CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc147) // CHECK-NEXT: %24 = arith.addi %5, %23 : i256 loc(#loc147) -// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc147) -// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc147) +// CHECK-NEXT: %25 = arith.cmpi ugt, %24, %c18446744073709551615_i256 : i256 loc(#loc147) +// CHECK-NEXT: %26 = arith.cmpi ult, %24, %5 : i256 loc(#loc147) +// CHECK-NEXT: %27 = arith.ori %25, %26 : i1 loc(#loc147) +// CHECK-NEXT: scf.if %27 { +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc147) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc147) +// CHECK-NEXT: %30 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc147) +// CHECK-NEXT: llvm.store %c65_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc147) +// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc147) +// CHECK-NEXT: "llvm.intrcall"(%31, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc147) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc147) +// CHECK-NEXT: } loc(#loc147) +// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc147) +// CHECK-NEXT: llvm.store %24, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc147) // CHECK-NEXT: call @f_string_12(%5) : (i256) -> () loc(#loc148) // CHECK-NEXT: return loc(#loc142) // CHECK-NEXT: } loc(#loc142) // CHECK-NEXT: func.func @fstr_bb_388(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:94:17), %arg1: !llvm.struct<(i256, i256)> loc({{.*}}:94:36)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1395,12 +1763,26 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %20 = arith.addi %19, %c31_i256 : i256 loc(#loc154) // CHECK-NEXT: %21 = arith.andi %20, %c-32_i256 : i256 loc(#loc154) // CHECK-NEXT: %22 = arith.addi %5, %21 : i256 loc(#loc154) -// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc154) -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc154) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c18446744073709551615_i256 : i256 loc(#loc154) +// CHECK-NEXT: %24 = arith.cmpi ult, %22, %5 : i256 loc(#loc154) +// CHECK-NEXT: %25 = arith.ori %23, %24 : i1 loc(#loc154) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc154) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc154) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc154) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc154) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc154) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc154) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc154) +// CHECK-NEXT: } loc(#loc154) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc154) +// CHECK-NEXT: llvm.store %22, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc154) // CHECK-NEXT: call @f_string_12(%5) : (i256) -> () loc(#loc155) // CHECK-NEXT: return loc(#loc149) // CHECK-NEXT: } loc(#loc149) // CHECK-NEXT: func.func @fstr_dd_405(%arg0: i256 loc({{.*}}:98:17), %arg1: i256 loc({{.*}}:98:35)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -1435,35 +1817,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %15 = arith.trunci %10 : i256 to i1 loc(#loc161) // CHECK-NEXT: %16 = arith.cmpi eq, %15, %14 : i1 loc(#loc161) // CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %41 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %c34_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: "llvm.intrcall"(%42, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc161) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %c34_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc161) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc161) // CHECK-NEXT: } loc(#loc161) // CHECK-NEXT: %17 = arith.andi %8, %c1_i256 : i256 loc(#loc161) // CHECK-NEXT: %18 = arith.cmpi eq, %17, %c0_i256 : i256 loc(#loc161) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %40 = arith.andi %8, %c-256_i256 : i256 loc(#loc161) -// CHECK-NEXT: %41 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %43 = arith.andi %8, %c-256_i256 : i256 loc(#loc161) +// CHECK-NEXT: %44 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) // CHECK-NEXT: } else { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %2, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %42 = "llvm.intrcall"(%41, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc161) -// CHECK-NEXT: %43 = arith.index_castui %13 : i256 to index loc(#loc161) -// CHECK-NEXT: scf.for %arg2 = %c0 to %43 step %c32 { -// CHECK-NEXT: %44 = arith.index_castui %arg2 : index to i256 loc(#loc161) -// CHECK-NEXT: %45 = arith.divui %44, %c32_i256 : i256 loc(#loc161) -// CHECK-NEXT: %46 = arith.addi %42, %45 : i256 loc(#loc161) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<5> loc(#loc161) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc161) -// CHECK-NEXT: %49 = arith.addi %6, %44 : i256 loc(#loc161) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %48, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %2, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %45 = "llvm.intrcall"(%44, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc161) +// CHECK-NEXT: %46 = arith.index_castui %13 : i256 to index loc(#loc161) +// CHECK-NEXT: scf.for %arg2 = %c0 to %46 step %c32 { +// CHECK-NEXT: %47 = arith.index_castui %arg2 : index to i256 loc(#loc161) +// CHECK-NEXT: %48 = arith.divui %47, %c32_i256 : i256 loc(#loc161) +// CHECK-NEXT: %49 = arith.addi %45, %48 : i256 loc(#loc161) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<5> loc(#loc161) +// CHECK-NEXT: %51 = llvm.load %50 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc161) +// CHECK-NEXT: %52 = arith.addi %6, %47 : i256 loc(#loc161) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %51, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) // CHECK-NEXT: } loc(#loc161) // CHECK-NEXT: } loc(#loc161) // CHECK-NEXT: %19 = arith.addi %6, %13 : i256 loc(#loc161) @@ -1478,35 +1860,35 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %28 = arith.trunci %23 : i256 to i1 loc(#loc161) // CHECK-NEXT: %29 = arith.cmpi eq, %28, %27 : i1 loc(#loc161) // CHECK-NEXT: scf.if %29 { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %41 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %c34_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: "llvm.intrcall"(%42, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc161) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %c34_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc161) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc161) // CHECK-NEXT: } loc(#loc161) // CHECK-NEXT: %30 = arith.andi %21, %c1_i256 : i256 loc(#loc161) // CHECK-NEXT: %31 = arith.cmpi eq, %30, %c0_i256 : i256 loc(#loc161) // CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %40 = arith.andi %21, %c-256_i256 : i256 loc(#loc161) -// CHECK-NEXT: %41 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %40, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %43 = arith.andi %21, %c-256_i256 : i256 loc(#loc161) +// CHECK-NEXT: %44 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) // CHECK-NEXT: } else { -// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %3, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: %42 = "llvm.intrcall"(%41, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc161) -// CHECK-NEXT: %43 = arith.index_castui %26 : i256 to index loc(#loc161) -// CHECK-NEXT: scf.for %arg2 = %c0 to %43 step %c32 { -// CHECK-NEXT: %44 = arith.index_castui %arg2 : index to i256 loc(#loc161) -// CHECK-NEXT: %45 = arith.divui %44, %c32_i256 : i256 loc(#loc161) -// CHECK-NEXT: %46 = arith.addi %42, %45 : i256 loc(#loc161) -// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<5> loc(#loc161) -// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc161) -// CHECK-NEXT: %49 = arith.addi %19, %44 : i256 loc(#loc161) -// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %48, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %3, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %45 = "llvm.intrcall"(%44, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc161) +// CHECK-NEXT: %46 = arith.index_castui %26 : i256 to index loc(#loc161) +// CHECK-NEXT: scf.for %arg2 = %c0 to %46 step %c32 { +// CHECK-NEXT: %47 = arith.index_castui %arg2 : index to i256 loc(#loc161) +// CHECK-NEXT: %48 = arith.divui %47, %c32_i256 : i256 loc(#loc161) +// CHECK-NEXT: %49 = arith.addi %45, %48 : i256 loc(#loc161) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<5> loc(#loc161) +// CHECK-NEXT: %51 = llvm.load %50 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc161) +// CHECK-NEXT: %52 = arith.addi %19, %47 : i256 loc(#loc161) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %51, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) // CHECK-NEXT: } loc(#loc161) // CHECK-NEXT: } loc(#loc161) // CHECK-NEXT: %32 = arith.addi %19, %26 : i256 loc(#loc161) @@ -1517,12 +1899,30 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %36 = arith.addi %35, %c31_i256 : i256 loc(#loc161) // CHECK-NEXT: %37 = arith.andi %36, %c-32_i256 : i256 loc(#loc161) // CHECK-NEXT: %38 = arith.addi %5, %37 : i256 loc(#loc161) -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc161) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %39 = arith.cmpi ugt, %38, %c18446744073709551615_i256 : i256 loc(#loc161) +// CHECK-NEXT: %40 = arith.cmpi ult, %38, %5 : i256 loc(#loc161) +// CHECK-NEXT: %41 = arith.ori %39, %40 : i1 loc(#loc161) +// CHECK-NEXT: scf.if %41 { +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %44 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %c65_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: "llvm.intrcall"(%45, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc161) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc161) +// CHECK-NEXT: } loc(#loc161) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc161) +// CHECK-NEXT: llvm.store %38, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc161) // CHECK-NEXT: call @f_string_12(%5) : (i256) -> () loc(#loc162) // CHECK-NEXT: return loc(#loc156) // CHECK-NEXT: } loc(#loc156) // CHECK-NEXT: func.func @fstr_ab_422(%arg0: i256 loc({{.*}}:102:17), %arg1: !llvm.struct<(i256, i256)> loc({{.*}}:102:34)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1557,34 +1957,46 @@ function fstr_ab(string memory a, string calldata b) { // CHECK-NEXT: %21 = arith.addi %20, %c31_i256 : i256 loc(#loc168) // CHECK-NEXT: %22 = arith.andi %21, %c-32_i256 : i256 loc(#loc168) // CHECK-NEXT: %23 = arith.addi %5, %22 : i256 loc(#loc168) -// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc168) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc168) +// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %c18446744073709551615_i256 : i256 loc(#loc168) +// CHECK-NEXT: %25 = arith.cmpi ult, %23, %5 : i256 loc(#loc168) +// CHECK-NEXT: %26 = arith.ori %24, %25 : i1 loc(#loc168) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc168) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc168) +// CHECK-NEXT: %29 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc168) +// CHECK-NEXT: llvm.store %c65_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc168) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc168) +// CHECK-NEXT: "llvm.intrcall"(%30, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc168) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc168) +// CHECK-NEXT: } loc(#loc168) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc168) +// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc168) // CHECK-NEXT: call @f_string_12(%5) : (i256) -> () loc(#loc169) // CHECK-NEXT: return loc(#loc163) // CHECK-NEXT: } loc(#loc163) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: #loc = loc(unknown) -// CHECK-NEXT: #loc1 = loc({{.*}}:19:12) +// CHECK-NEXT: #loc1 = loc({{.*}}:7:12) // CHECK-NEXT: #loc2 = loc({{.*}}:2:0) // CHECK-NEXT: #loc4 = loc({{.*}}:4:0) // CHECK-NEXT: #loc6 = loc({{.*}}:6:0) // CHECK-NEXT: #loc9 = loc({{.*}}:7:25) // CHECK-NEXT: #loc10 = loc({{.*}}:7:28) -// CHECK-NEXT: #loc11 = loc({{.*}}:7:12) -// CHECK-NEXT: #loc12 = loc({{.*}}:7:4) -// CHECK-NEXT: #loc13 = loc({{.*}}:10:0) -// CHECK-NEXT: #loc16 = loc({{.*}}:11:25) -// CHECK-NEXT: #loc17 = loc({{.*}}:11:28) -// CHECK-NEXT: #loc18 = loc({{.*}}:11:12) -// CHECK-NEXT: #loc19 = loc({{.*}}:11:4) -// CHECK-NEXT: #loc20 = loc({{.*}}:14:0) -// CHECK-NEXT: #loc23 = loc({{.*}}:15:25) -// CHECK-NEXT: #loc24 = loc({{.*}}:15:28) -// CHECK-NEXT: #loc25 = loc({{.*}}:15:12) -// CHECK-NEXT: #loc26 = loc({{.*}}:15:4) -// CHECK-NEXT: #loc27 = loc({{.*}}:18:0) -// CHECK-NEXT: #loc30 = loc({{.*}}:19:25) -// CHECK-NEXT: #loc31 = loc({{.*}}:19:28) +// CHECK-NEXT: #loc11 = loc({{.*}}:7:4) +// CHECK-NEXT: #loc12 = loc({{.*}}:10:0) +// CHECK-NEXT: #loc15 = loc({{.*}}:11:25) +// CHECK-NEXT: #loc16 = loc({{.*}}:11:28) +// CHECK-NEXT: #loc17 = loc({{.*}}:11:12) +// CHECK-NEXT: #loc18 = loc({{.*}}:11:4) +// CHECK-NEXT: #loc19 = loc({{.*}}:14:0) +// CHECK-NEXT: #loc22 = loc({{.*}}:15:25) +// CHECK-NEXT: #loc23 = loc({{.*}}:15:28) +// CHECK-NEXT: #loc24 = loc({{.*}}:15:12) +// CHECK-NEXT: #loc25 = loc({{.*}}:15:4) +// CHECK-NEXT: #loc26 = loc({{.*}}:18:0) +// CHECK-NEXT: #loc29 = loc({{.*}}:19:25) +// CHECK-NEXT: #loc30 = loc({{.*}}:19:28) +// CHECK-NEXT: #loc31 = loc({{.*}}:19:12) // CHECK-NEXT: #loc32 = loc({{.*}}:19:4) // CHECK-NEXT: #loc33 = loc({{.*}}:22:0) // CHECK-NEXT: #loc36 = loc({{.*}}:23:25) diff --git a/test/lit/mlirCodegen/EVM/contract-cast.sol b/test/lit/mlirCodegen/EVM/contract-cast.sol index a803bda8f..9c8f46e33 100644 --- a/test/lit/mlirCodegen/EVM/contract-cast.sol +++ b/test/lit/mlirCodegen/EVM/contract-cast.sol @@ -14,6 +14,13 @@ contract B is A { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -22,8 +29,8 @@ contract B is A { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_1"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -31,22 +38,36 @@ contract B is A { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @A_1() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_1_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_1_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_1_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_1_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -78,6 +99,13 @@ contract B is A { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -86,8 +114,8 @@ contract B is A { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["B_15"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -95,22 +123,36 @@ contract B is A { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @B_15() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["B_15_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["B_15_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["B_15_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["B_15_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/contract-cmp.sol b/test/lit/mlirCodegen/EVM/contract-cmp.sol index fa06300b7..cf11a6d85 100644 --- a/test/lit/mlirCodegen/EVM/contract-cmp.sol +++ b/test/lit/mlirCodegen/EVM/contract-cmp.sol @@ -20,6 +20,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -28,8 +35,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_33"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -37,22 +44,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_33() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_33_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_33_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_33_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_33_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/create-fail.sol b/test/lit/mlirCodegen/EVM/create-fail.sol index 90ada1c4a..462d585b1 100644 --- a/test/lit/mlirCodegen/EVM/create-fail.sol +++ b/test/lit/mlirCodegen/EVM/create-fail.sol @@ -22,6 +22,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -30,8 +37,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Failer_8"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -39,22 +46,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @_7() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Failer_8_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Failer_8_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Failer_8_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Failer_8_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -92,6 +113,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -100,8 +128,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_35"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -109,22 +137,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_35() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_35_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_35_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_35_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_35_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/crypto_hash.sol b/test/lit/mlirCodegen/EVM/crypto_hash.sol index 273d9dbc7..e5058d02b 100644 --- a/test/lit/mlirCodegen/EVM/crypto_hash.sol +++ b/test/lit/mlirCodegen/EVM/crypto_hash.sol @@ -137,6 +137,11 @@ function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) { // CHECK-NEXT: } loc(#loc17) // CHECK-NEXT: func.func @recover_75(%arg0: i256 loc({{.*}}:18:17), %arg1: i8 loc({{.*}}:18:31), %arg2: i256 loc({{.*}}:18:40), %arg3: i256 loc({{.*}}:18:51)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -169,29 +174,41 @@ function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) { // CHECK-NEXT: %17 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc31) // CHECK-NEXT: llvm.store %7, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) // CHECK-NEXT: %18 = arith.addi %9, %c128_i256 : i256 loc(#loc31) -// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc31) -// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: llvm.store %c0_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %22 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %24 = "llvm.intrcall"(%20, %c1_i256, %22, %c128_i256, %23, %c32_i256) <{id = 4090 : i32, name = "evm.staticcall"}> : (i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc31) -// CHECK-NEXT: %25 = arith.cmpi eq, %24, %c0_i256 : i256 loc(#loc31) -// CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: %30 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc31) -// CHECK-NEXT: %31 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc31) -// CHECK-NEXT: "llvm.intr.memcpy"(%31, %32, %30) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc31) -// CHECK-NEXT: %33 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: "llvm.intrcall"(%33, %30) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc31) +// CHECK-NEXT: %19 = arith.cmpi ugt, %18, %c18446744073709551615_i256 : i256 loc(#loc31) +// CHECK-NEXT: %20 = arith.cmpi ult, %18, %9 : i256 loc(#loc31) +// CHECK-NEXT: %21 = arith.ori %19, %20 : i1 loc(#loc31) +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %32 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c65_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: "llvm.intrcall"(%33, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc31) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc31) // CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %22 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %18, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %23 = "llvm.intrcall"() <{id = 4055 : i32, name = "evm.gas"}> : () -> i256 loc(#loc31) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: llvm.store %c0_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %25 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc31) // CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) -// CHECK-NEXT: call @f_address_18(%27) : (i256) -> () loc(#loc32) +// CHECK-NEXT: %27 = "llvm.intrcall"(%23, %c1_i256, %25, %c128_i256, %26, %c32_i256) <{id = 4090 : i32, name = "evm.staticcall"}> : (i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc31) +// CHECK-NEXT: %28 = arith.cmpi eq, %27, %c0_i256 : i256 loc(#loc31) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %32 = llvm.load %31 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) +// CHECK-NEXT: %33 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc31) +// CHECK-NEXT: %34 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<3> loc(#loc31) +// CHECK-NEXT: "llvm.intr.memcpy"(%34, %35, %33) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc31) +// CHECK-NEXT: %36 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: "llvm.intrcall"(%36, %33) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc31) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc31) +// CHECK-NEXT: } loc(#loc31) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc31) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc31) +// CHECK-NEXT: call @f_address_18(%30) : (i256) -> () loc(#loc32) // CHECK-NEXT: return loc(#loc22) // CHECK-NEXT: } loc(#loc22) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/ctor.sol b/test/lit/mlirCodegen/EVM/ctor.sol index 3c37e7078..c0fa5ab19 100644 --- a/test/lit/mlirCodegen/EVM/ctor.sol +++ b/test/lit/mlirCodegen/EVM/ctor.sol @@ -22,6 +22,13 @@ contract C is D { // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -30,8 +37,8 @@ contract C is D { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%22, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["E_15"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -39,30 +46,44 @@ contract C is D { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %12 = arith.cmpi slt, %5, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%22, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = arith.cmpi slt, %5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %13 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: call @_14(%14) : (i256) -> () loc(#loc1) -// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %17 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["E_15_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %18 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["E_15_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%19, %20, %18) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%21, %18) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %18 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: call @_14(%19) : (i256) -> () loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %22 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["E_15_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %23 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["E_15_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %22 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%24, %25, %23) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %23) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -181,6 +202,13 @@ contract C is D { // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc2) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -189,8 +217,8 @@ contract C is D { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc2) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc2) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%25, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_37"], name = "evm.datasize"}> : () -> i256 loc(#loc2) @@ -198,33 +226,47 @@ contract C is D { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc2) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc2) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc2) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) -// CHECK-NEXT: %12 = arith.cmpi slt, %5, %c64_i256 : i256 loc(#loc2) -// CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%25, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc2) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc2) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc2) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc2) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc2) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) // CHECK-NEXT: } loc(#loc2) -// CHECK-NEXT: %13 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %15 = arith.addi %7, %c32_i256 : i256 loc(#loc2) -// CHECK-NEXT: %16 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: call @_36(%14, %17) : (i256, i256) -> () loc(#loc2) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc2) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) +// CHECK-NEXT: %17 = arith.cmpi slt, %5, %c64_i256 : i256 loc(#loc2) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %18 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) // CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_37_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc2) -// CHECK-NEXT: %21 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_37_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc2) -// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %23 = llvm.inttoptr %20 : i256 to !llvm.ptr<4> loc(#loc2) -// CHECK-NEXT: "llvm.intr.memcpy"(%22, %23, %21) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) -// CHECK-NEXT: %24 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%24, %21) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: %20 = arith.addi %7, %c32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %21 = llvm.inttoptr %20 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: call @_36(%19, %22) : (i256, i256) -> () loc(#loc2) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: %25 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_37_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc2) +// CHECK-NEXT: %26 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_37_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc2) +// CHECK-NEXT: %27 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %28 = llvm.inttoptr %25 : i256 to !llvm.ptr<4> loc(#loc2) +// CHECK-NEXT: "llvm.intr.memcpy"(%27, %28, %26) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) +// CHECK-NEXT: %29 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%29, %26) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc2) // CHECK-NEXT: llvm.unreachable loc(#loc2) // CHECK-NEXT: } loc(#loc) @@ -450,6 +492,13 @@ contract C is D { // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc2) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -458,8 +507,8 @@ contract C is D { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc2) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc2) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%22, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_58"], name = "evm.datasize"}> : () -> i256 loc(#loc2) @@ -467,30 +516,44 @@ contract C is D { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc2) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc2) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc2) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) -// CHECK-NEXT: %12 = arith.cmpi slt, %5, %c32_i256 : i256 loc(#loc2) -// CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%22, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc2) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc2) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc2) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc2) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc2) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc2) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) +// CHECK-NEXT: %17 = arith.cmpi slt, %5, %c32_i256 : i256 loc(#loc2) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) // CHECK-NEXT: } loc(#loc2) -// CHECK-NEXT: %13 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: call @_57(%14) : (i256) -> () loc(#loc2) -// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %17 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_58_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc2) -// CHECK-NEXT: %18 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_58_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc2) -// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<4> loc(#loc2) -// CHECK-NEXT: "llvm.intr.memcpy"(%19, %20, %18) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) -// CHECK-NEXT: %21 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%21, %18) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: %18 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: call @_57(%19) : (i256) -> () loc(#loc2) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: %22 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_58_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc2) +// CHECK-NEXT: %23 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_58_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc2) +// CHECK-NEXT: %24 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %25 = llvm.inttoptr %22 : i256 to !llvm.ptr<4> loc(#loc2) +// CHECK-NEXT: "llvm.intr.memcpy"(%24, %25, %23) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) +// CHECK-NEXT: %26 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%26, %23) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc2) // CHECK-NEXT: llvm.unreachable loc(#loc2) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/custom-storage-layout.sol b/test/lit/mlirCodegen/EVM/custom-storage-layout.sol index af5d68612..75bddf5a1 100644 --- a/test/lit/mlirCodegen/EVM/custom-storage-layout.sol +++ b/test/lit/mlirCodegen/EVM/custom-storage-layout.sol @@ -18,6 +18,13 @@ contract C is A layout at BASE * 2 { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -26,8 +33,8 @@ contract C is A layout at BASE * 2 { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_6"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -35,22 +42,36 @@ contract C is A layout at BASE * 2 { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @A_6() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_6_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_6_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_6_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_6_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -82,6 +103,13 @@ contract C is A layout at BASE * 2 { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -90,8 +118,8 @@ contract C is A layout at BASE * 2 { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_17"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -99,22 +127,36 @@ contract C is A layout at BASE * 2 { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_17() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_17_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_17_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_17_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_17_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/erc20.sol b/test/lit/mlirCodegen/EVM/erc20.sol index d447dbabb..fa610c5a3 100644 --- a/test/lit/mlirCodegen/EVM/erc20.sol +++ b/test/lit/mlirCodegen/EVM/erc20.sol @@ -185,27 +185,28 @@ contract ERC20 { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) -// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256 = arith.constant 45888551966424197807937402689295079693071411769653575580334356259971920822272 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256 = arith.constant 29517451764962235613010368778373659638394623262010481748738546747006033225331 : i256 loc(#loc) // CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -214,8 +215,8 @@ contract ERC20 { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %72 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%72, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%85, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["ERC20_470"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -223,232 +224,272 @@ contract ERC20 { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %12 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %13 = arith.cmpi slt, %5, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) // CHECK-NEXT: scf.if %13 { -// CHECK-NEXT: %72 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%72, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %14 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %72 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %73, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = arith.addi %73, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %73, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %73, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%83, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = arith.addi %7, %5 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.cmpi slt, %5, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%85, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %17 = arith.addi %7, %15 : i256 loc(#loc1) -// CHECK-NEXT: %18 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %19 = arith.cmpi sge, %18, %12 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %72 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %73, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = arith.addi %73, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %73, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %73, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%83, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %21 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.addi %22, %21 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %12 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.addi %7, %20 : i256 loc(#loc1) +// CHECK-NEXT: %23 = arith.addi %22, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %24 = arith.cmpi sge, %23, %17 : i256 loc(#loc1) // CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %72 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %73, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = arith.addi %73, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %73, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %73, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%83, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %25 = arith.addi %21, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %26 = arith.andi %25, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %27 { -// CHECK-NEXT: %72 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%74, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %22, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %27, %26 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.cmpi ugt, %28, %17 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %28 = arith.addi %26, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.addi %30, %28 : i256 loc(#loc1) -// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %31, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %21, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = arith.addi %30, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %35 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%35, %36, %21) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %37 = arith.addi %34, %21 : i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = arith.addi %7, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %42 { -// CHECK-NEXT: %72 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %73, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = arith.addi %73, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %73, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %73, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%83, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %26, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.andi %30, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ugt, %26, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %32 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %7, %41 : i256 loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %43, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.cmpi sge, %44, %12 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %45 { -// CHECK-NEXT: %72 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %73, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = arith.addi %73, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %73, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %73, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%83, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %33 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %35 = arith.addi %31, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %36 = arith.andi %35, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.addi %34, %36 : i256 loc(#loc1) +// CHECK-NEXT: %38 = arith.cmpi ugt, %37, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.cmpi ult, %37, %34 : i256 loc(#loc1) +// CHECK-NEXT: %40 = arith.ori %38, %39 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %40 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %43, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %48, %47 : i256 loc(#loc1) -// CHECK-NEXT: %50 = arith.cmpi ugt, %49, %12 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %50 { -// CHECK-NEXT: %72 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.load %72 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %74 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %75 = arith.addi %73, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %76 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %76 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %77 = arith.addi %73, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %78 = llvm.inttoptr %77 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %79 = arith.addi %73, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %80 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %80 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %81 = arith.addi %73, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %82 = llvm.inttoptr %81 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %83 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%83, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %37, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %26, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = arith.addi %34, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%44, %45, %26) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %43, %26 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %7, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.cmpi ugt, %50, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %51 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %47, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %52 = arith.andi %51, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %53 = arith.cmpi ugt, %47, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %53 { -// CHECK-NEXT: %72 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %73 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %74 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%74, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %7, %50 : i256 loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %52, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.cmpi sge, %53, %17 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %54 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %54 = arith.addi %52, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %56, %54 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %57, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %47, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %56, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%61, %62, %47) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %60, %47 : i256 loc(#loc1) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: call @_49(%30, %56) : (i256, i256) -> () loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %66 = llvm.load %65 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %67 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["ERC20_470_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %68 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["ERC20_470_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %69 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %67 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%69, %70, %68) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %71 = llvm.inttoptr %66 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%71, %68) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %57 = arith.addi %52, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.addi %57, %56 : i256 loc(#loc1) +// CHECK-NEXT: %59 = arith.cmpi ugt, %58, %17 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %59 { +// CHECK-NEXT: %85 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %87 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %88 = arith.addi %86, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %89 = llvm.inttoptr %88 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %89 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %90 = arith.addi %86, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %91 = llvm.inttoptr %90 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %91 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %92 = arith.addi %86, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %93 = llvm.inttoptr %92 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %93 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %94 = arith.addi %86, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %95 = llvm.inttoptr %94 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %96 = llvm.inttoptr %86 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%96, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %60 = arith.addi %56, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %61 = arith.andi %60, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.cmpi ugt, %56, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %62 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %63 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %64 = llvm.load %63 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %61, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.andi %65, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %64, %66 : i256 loc(#loc1) +// CHECK-NEXT: %68 = arith.cmpi ugt, %67, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %69 = arith.cmpi ult, %67, %64 : i256 loc(#loc1) +// CHECK-NEXT: %70 = arith.ori %68, %69 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %70 { +// CHECK-NEXT: %85 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %85 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %86 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %86 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %87 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%87, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %67, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %72 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %56, %72 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %73 = arith.addi %64, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %74 = llvm.inttoptr %73 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%74, %75, %56) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %73, %56 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: call @_49(%34, %64) : (i256, i256) -> () loc(#loc1) +// CHECK-NEXT: %78 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %79 = llvm.load %78 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %80 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["ERC20_470_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %81 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["ERC20_470_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %82 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %83 = llvm.inttoptr %80 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%82, %83, %81) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %84 = llvm.inttoptr %79 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%84, %81) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -710,8 +751,8 @@ contract ERC20 { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = func.call @name_66() : () -> i256 loc(#loc1) @@ -727,14 +768,17 @@ contract ERC20 { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -742,8 +786,8 @@ contract ERC20 { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = func.call @symbol_74() : () -> i256 loc(#loc1) @@ -759,14 +803,17 @@ contract ERC20 { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1942,9 +1989,12 @@ contract ERC20 { // CHECK-NEXT: return %c18_i256 : i256 loc(#loc165) // CHECK-NEXT: } loc(#loc163) // CHECK-NEXT: func.func @symbol_74() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) @@ -1967,56 +2017,72 @@ contract ERC20 { // CHECK-NEXT: %8 = arith.trunci %3 : i256 to i1 loc(#loc167) // CHECK-NEXT: %9 = arith.cmpi eq, %8, %7 : i1 loc(#loc167) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %23 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %c34_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: "llvm.intrcall"(%24, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc167) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %c34_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc167) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc167) // CHECK-NEXT: } loc(#loc167) // CHECK-NEXT: %10 = arith.addi %6, %c31_i256 : i256 loc(#loc167) // CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc167) -// CHECK-NEXT: %12 = arith.addi %11, %c32_i256 : i256 loc(#loc167) -// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc167) -// CHECK-NEXT: %15 = arith.addi %14, %12 : i256 loc(#loc167) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %6, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %18 = arith.addi %14, %c32_i256 : i256 loc(#loc167) -// CHECK-NEXT: %19 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %6, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %20 = arith.andi %1, %c1_i256 : i256 loc(#loc167) -// CHECK-NEXT: %21 = arith.cmpi eq, %20, %c0_i256 : i256 loc(#loc167) -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %22 = arith.andi %1, %c-256_i256 : i256 loc(#loc167) -// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc167) +// CHECK-NEXT: %14 = arith.addi %11, %c63_i256 : i256 loc(#loc167) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc167) +// CHECK-NEXT: %16 = arith.addi %13, %15 : i256 loc(#loc167) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc167) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %13 : i256 loc(#loc167) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc167) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc167) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc167) +// CHECK-NEXT: } loc(#loc167) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %6, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %22 = arith.addi %13, %c32_i256 : i256 loc(#loc167) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %6, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %24 = arith.andi %1, %c1_i256 : i256 loc(#loc167) +// CHECK-NEXT: %25 = arith.cmpi eq, %24, %c0_i256 : i256 loc(#loc167) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %26 = arith.andi %1, %c-256_i256 : i256 loc(#loc167) +// CHECK-NEXT: %27 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) // CHECK-NEXT: } else { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %c4_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: %24 = "llvm.intrcall"(%23, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc167) -// CHECK-NEXT: %25 = arith.index_castui %6 : i256 to index loc(#loc167) -// CHECK-NEXT: scf.for %arg0 = %c0 to %25 step %c32 { -// CHECK-NEXT: %26 = arith.index_castui %arg0 : index to i256 loc(#loc167) -// CHECK-NEXT: %27 = arith.divui %26, %c32_i256 : i256 loc(#loc167) -// CHECK-NEXT: %28 = arith.addi %24, %27 : i256 loc(#loc167) -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<5> loc(#loc167) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc167) -// CHECK-NEXT: %31 = arith.addi %18, %26 : i256 loc(#loc167) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc167) -// CHECK-NEXT: llvm.store %30, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %c4_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: %28 = "llvm.intrcall"(%27, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc167) +// CHECK-NEXT: %29 = arith.index_castui %6 : i256 to index loc(#loc167) +// CHECK-NEXT: scf.for %arg0 = %c0 to %29 step %c32 { +// CHECK-NEXT: %30 = arith.index_castui %arg0 : index to i256 loc(#loc167) +// CHECK-NEXT: %31 = arith.divui %30, %c32_i256 : i256 loc(#loc167) +// CHECK-NEXT: %32 = arith.addi %28, %31 : i256 loc(#loc167) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<5> loc(#loc167) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc167) +// CHECK-NEXT: %35 = arith.addi %22, %30 : i256 loc(#loc167) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc167) +// CHECK-NEXT: llvm.store %34, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc167) // CHECK-NEXT: } loc(#loc167) // CHECK-NEXT: } loc(#loc167) -// CHECK-NEXT: return %14 : i256 loc(#loc168) +// CHECK-NEXT: return %13 : i256 loc(#loc168) // CHECK-NEXT: } loc(#loc166) // CHECK-NEXT: func.func @name_66() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) @@ -2040,51 +2106,64 @@ contract ERC20 { // CHECK-NEXT: %8 = arith.trunci %3 : i256 to i1 loc(#loc170) // CHECK-NEXT: %9 = arith.cmpi eq, %8, %7 : i1 loc(#loc170) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %23 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %c34_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: "llvm.intrcall"(%24, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc170) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c34_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc170) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc170) // CHECK-NEXT: } loc(#loc170) // CHECK-NEXT: %10 = arith.addi %6, %c31_i256 : i256 loc(#loc170) // CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc170) -// CHECK-NEXT: %12 = arith.addi %11, %c32_i256 : i256 loc(#loc170) -// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc170) -// CHECK-NEXT: %15 = arith.addi %14, %12 : i256 loc(#loc170) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %6, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %18 = arith.addi %14, %c32_i256 : i256 loc(#loc170) -// CHECK-NEXT: %19 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %6, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %20 = arith.andi %1, %c1_i256 : i256 loc(#loc170) -// CHECK-NEXT: %21 = arith.cmpi eq, %20, %c0_i256 : i256 loc(#loc170) -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %22 = arith.andi %1, %c-256_i256 : i256 loc(#loc170) -// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc170) +// CHECK-NEXT: %14 = arith.addi %11, %c63_i256 : i256 loc(#loc170) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %16 = arith.addi %13, %15 : i256 loc(#loc170) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc170) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %13 : i256 loc(#loc170) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc170) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc170) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc170) +// CHECK-NEXT: } loc(#loc170) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %6, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %22 = arith.addi %13, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %6, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %24 = arith.andi %1, %c1_i256 : i256 loc(#loc170) +// CHECK-NEXT: %25 = arith.cmpi eq, %24, %c0_i256 : i256 loc(#loc170) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %26 = arith.andi %1, %c-256_i256 : i256 loc(#loc170) +// CHECK-NEXT: %27 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) // CHECK-NEXT: } else { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %c3_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %24 = "llvm.intrcall"(%23, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc170) -// CHECK-NEXT: %25 = arith.index_castui %6 : i256 to index loc(#loc170) -// CHECK-NEXT: scf.for %arg0 = %c0 to %25 step %c32 { -// CHECK-NEXT: %26 = arith.index_castui %arg0 : index to i256 loc(#loc170) -// CHECK-NEXT: %27 = arith.divui %26, %c32_i256 : i256 loc(#loc170) -// CHECK-NEXT: %28 = arith.addi %24, %27 : i256 loc(#loc170) -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<5> loc(#loc170) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc170) -// CHECK-NEXT: %31 = arith.addi %18, %26 : i256 loc(#loc170) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %30, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c3_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %28 = "llvm.intrcall"(%27, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc170) +// CHECK-NEXT: %29 = arith.index_castui %6 : i256 to index loc(#loc170) +// CHECK-NEXT: scf.for %arg0 = %c0 to %29 step %c32 { +// CHECK-NEXT: %30 = arith.index_castui %arg0 : index to i256 loc(#loc170) +// CHECK-NEXT: %31 = arith.divui %30, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %32 = arith.addi %28, %31 : i256 loc(#loc170) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<5> loc(#loc170) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc170) +// CHECK-NEXT: %35 = arith.addi %22, %30 : i256 loc(#loc170) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %34, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) // CHECK-NEXT: } loc(#loc170) // CHECK-NEXT: } loc(#loc170) -// CHECK-NEXT: return %14 : i256 loc(#loc171) +// CHECK-NEXT: return %13 : i256 loc(#loc171) // CHECK-NEXT: } loc(#loc169) // CHECK-NEXT: func.func @_msgSender_58() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %0 = "llvm.intrcall"() <{id = 4039 : i32, name = "evm.caller"}> : () -> i256 loc(#loc173) diff --git a/test/lit/mlirCodegen/EVM/event.sol b/test/lit/mlirCodegen/EVM/event.sol index 7622474a2..fcbbdacee 100644 --- a/test/lit/mlirCodegen/EVM/event.sol +++ b/test/lit/mlirCodegen/EVM/event.sol @@ -17,6 +17,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -25,8 +32,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_25"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -34,22 +41,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_25() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_25_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_25_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_25_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_25_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/ext-call.sol b/test/lit/mlirCodegen/EVM/ext-call.sol index 279e58d7a..ed28f6f14 100644 --- a/test/lit/mlirCodegen/EVM/ext-call.sol +++ b/test/lit/mlirCodegen/EVM/ext-call.sol @@ -15,6 +15,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -23,8 +30,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_24"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -32,22 +39,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_24() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_24_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_24_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_24_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_24_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -105,9 +126,14 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @f_23(%arg0: i256 loc({{.*}}:3:13)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c-34435155370463444793260793355178157075203752403645521721995013737368954863616_i256 = arith.constant -34435155370463444793260793355178157075203752403645521721995013737368954863616 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -148,17 +174,43 @@ contract C { // CHECK-NEXT: %32 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc4) // CHECK-NEXT: %33 = arith.cmpi ult, %32, %c32_i256 : i256 loc(#loc4) // CHECK-NEXT: %34 = scf.if %33 -> (i256) { -// CHECK-NEXT: %39 = arith.addi %7, %32 : i256 loc(#loc4) -// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %41 = arith.addi %7, %32 : i256 loc(#loc4) -// CHECK-NEXT: scf.yield %41 : i256 loc(#loc4) +// CHECK-NEXT: %39 = arith.addi %32, %c31_i256 : i256 loc(#loc4) +// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %41 = arith.addi %7, %40 : i256 loc(#loc4) +// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %43 = arith.cmpi ult, %41, %7 : i256 loc(#loc4) +// CHECK-NEXT: %44 = arith.ori %42, %43 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %48 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %49 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%49, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %41, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %46 = arith.addi %7, %32 : i256 loc(#loc4) +// CHECK-NEXT: scf.yield %46 : i256 loc(#loc4) // CHECK-NEXT: } else { // CHECK-NEXT: %39 = arith.addi %7, %c32_i256 : i256 loc(#loc4) -// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %41 = arith.addi %7, %c32_i256 : i256 loc(#loc4) -// CHECK-NEXT: scf.yield %41 : i256 loc(#loc4) +// CHECK-NEXT: %40 = arith.cmpi ugt, %39, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %41 = arith.cmpi ult, %39, %7 : i256 loc(#loc4) +// CHECK-NEXT: %42 = arith.ori %40, %41 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %42 { +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %39, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %44 = arith.addi %7, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: scf.yield %44 : i256 loc(#loc4) // CHECK-NEXT: } loc(#loc4) // CHECK-NEXT: %35 = arith.subi %34, %7 : i256 loc(#loc4) // CHECK-NEXT: %36 = arith.cmpi slt, %35, %c32_i256 : i256 loc(#loc4) @@ -205,17 +257,43 @@ contract C { // CHECK-NEXT: %32 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc8) // CHECK-NEXT: %33 = arith.cmpi ult, %32, %c32_i256 : i256 loc(#loc8) // CHECK-NEXT: %34 = scf.if %33 -> (i256) { -// CHECK-NEXT: %39 = arith.addi %22, %32 : i256 loc(#loc8) -// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %41 = arith.addi %22, %32 : i256 loc(#loc8) -// CHECK-NEXT: scf.yield %41 : i256 loc(#loc8) +// CHECK-NEXT: %39 = arith.addi %32, %c31_i256 : i256 loc(#loc8) +// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %41 = arith.addi %22, %40 : i256 loc(#loc8) +// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc8) +// CHECK-NEXT: %43 = arith.cmpi ult, %41, %22 : i256 loc(#loc8) +// CHECK-NEXT: %44 = arith.ori %42, %43 : i1 loc(#loc8) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %48 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c65_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %49 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%49, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %41, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %46 = arith.addi %22, %32 : i256 loc(#loc8) +// CHECK-NEXT: scf.yield %46 : i256 loc(#loc8) // CHECK-NEXT: } else { // CHECK-NEXT: %39 = arith.addi %22, %c32_i256 : i256 loc(#loc8) -// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %41 = arith.addi %22, %c32_i256 : i256 loc(#loc8) -// CHECK-NEXT: scf.yield %41 : i256 loc(#loc8) +// CHECK-NEXT: %40 = arith.cmpi ugt, %39, %c18446744073709551615_i256 : i256 loc(#loc8) +// CHECK-NEXT: %41 = arith.cmpi ult, %39, %22 : i256 loc(#loc8) +// CHECK-NEXT: %42 = arith.ori %40, %41 : i1 loc(#loc8) +// CHECK-NEXT: scf.if %42 { +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %39, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %44 = arith.addi %22, %c32_i256 : i256 loc(#loc8) +// CHECK-NEXT: scf.yield %44 : i256 loc(#loc8) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: %35 = arith.subi %34, %22 : i256 loc(#loc8) // CHECK-NEXT: %36 = arith.cmpi slt, %35, %c32_i256 : i256 loc(#loc8) diff --git a/test/lit/mlirCodegen/EVM/fn.sol b/test/lit/mlirCodegen/EVM/fn.sol index 5ab37b182..3248879a3 100644 --- a/test/lit/mlirCodegen/EVM/fn.sol +++ b/test/lit/mlirCodegen/EVM/fn.sol @@ -58,6 +58,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -66,8 +73,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_180"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -75,22 +82,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_180() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_180_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_180_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_180_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_180_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -102,28 +123,29 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c196_i256 = arith.constant 196 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) // CHECK-NEXT: %c-1766847064778384329583297500742918515827483896875618958121606201292619776_i256 = arith.constant -1766847064778384329583297500742918515827483896875618958121606201292619776 : i256 loc(#loc) // CHECK-NEXT: %c-452312848583266388373324160190187140051835877600158453279131187530910662656_i256 = arith.constant -452312848583266388373324160190187140051835877600158453279131187530910662656 : i256 loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256 = arith.constant 14665530690530801964634585719976680554868009180561069516385661492758486974464 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256 = arith.constant 29517451764962235613010368778373659638394623262010481663810023216111493996921 : i256 loc(#loc) // CHECK-NEXT: %c39_i256 = arith.constant 39 : i256 loc(#loc) -// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256 = arith.constant 45888551966424197807937402689295079693071411769653575580334356259971920822272 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256 = arith.constant 29517451764962235613010368778373659638394623262010481748738546747006033225331 : i256 loc(#loc) // CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) -// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c2 = arith.constant 2 : index loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256 = arith.constant 51765758038843778210450001422163835187549121709092664183213130986509706461184 : i256 loc(#loc) // CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256 = arith.constant 51765758038842110133680140445293787150925987327002253137507089023503727329280 : i256 loc(#loc) // CHECK-NEXT: %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256 = arith.constant 29517451764962235613010368778373659638394623262010481668089093425551466635361 : i256 loc(#loc) // CHECK-NEXT: %c43_i256 = arith.constant 43 : i256 loc(#loc) @@ -269,11 +291,7 @@ contract C { // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c2_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { // CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c33_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%21, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = func.call @e_58(%13) : (i256) -> i256 loc(#loc1) @@ -300,154 +318,178 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c192_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = arith.cmpi sle, %1, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %27 = arith.addi %25, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %25, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = arith.addi %25, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %33 = arith.addi %25, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%35, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %28, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = arith.addi %28, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %28, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %28, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%38, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %15 = arith.addi %14, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = arith.cmpi ult, %1, %c196_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %27 = arith.addi %25, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %25, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = arith.addi %25, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %33 = arith.addi %25, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%35, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %14 : i256 loc(#loc1) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %18:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %14, %arg2 = %c4_i256) -> (i256, i256) { -// CHECK-NEXT: %24 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.cmpi sge, %24, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = arith.addi %37, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %37, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %37, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = arith.cmpi ult, %1, %c196_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %20 { +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %28, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %32 = arith.addi %28, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %34 = arith.addi %28, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %28, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%38, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %21:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %14, %arg2 = %c4_i256) -> (i256, i256) { +// CHECK-NEXT: %27 = arith.addi %arg2, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.cmpi sge, %27, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %37, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%47, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %28 = arith.addi %27, %c64_i256 : i256 loc(#loc1) // CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %31 { -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = arith.addi %37, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %37, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %37, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.addi %30, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %30 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.cmpi ugt, %36, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %37 { +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %37, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %43, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%47, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %43, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %43, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %50 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %50 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %43, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %52 = llvm.inttoptr %51 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%53, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %32:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %27, %arg5 = %arg2) -> (i256, i256) { -// CHECK-NEXT: %36 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %37, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %39, %40 : i256, i256 loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %30, %arg5 = %arg2) -> (i256, i256) { +// CHECK-NEXT: %42 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %43, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %45, %46 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %27, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %34, %35 : i256, i256 loc(#loc1) +// CHECK-NEXT: %39 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %41 = arith.addi %arg2, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %40, %41 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %19 = func.call @arr_76(%14) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %22:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %21, %arg2 = %19) -> (i256, i256) { -// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %25 = llvm.load %24 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %26:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %arg1, %arg5 = %25) -> (i256, i256) { -// CHECK-NEXT: %29 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc1) +// CHECK-NEXT: %22 = func.call @arr_76(%14) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %25:2 = scf.for %arg0 = %c0 to %c3 step %c1 iter_args(%arg1 = %24, %arg2 = %22) -> (i256, i256) { +// CHECK-NEXT: %27 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %29:2 = scf.for %arg3 = %c0 to %c2 step %c1 iter_args(%arg4 = %arg1, %arg5 = %28) -> (i256, i256) { +// CHECK-NEXT: %32 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %35, %36 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %27 = arith.addi %arg1, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %28 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %27, %28 : i256, i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %arg1, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %30, %31 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %23 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%23, %c192_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c192_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -455,63 +497,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %51 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%51, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%55, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %51 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%51, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%55, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = arith.addi %56, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %52, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = arith.addi %56, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%62, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %56, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %64 = arith.addi %56, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%66, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = arith.addi %56, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %52, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = arith.addi %56, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%62, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %56, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %64 = arith.addi %56, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%66, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -521,83 +563,96 @@ contract C { // CHECK-NEXT: %22 = arith.addi %20, %21 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = arith.addi %56, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %60 = arith.addi %52, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = arith.addi %56, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %61 = llvm.inttoptr %60 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%62, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %62 = arith.addi %56, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %63 = llvm.inttoptr %62 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %63 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %64 = arith.addi %56, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %65 = llvm.inttoptr %64 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %65 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%66, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.muli %19, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %51 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %55 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%57, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = arith.index_castui %19 : i256 to index loc(#loc1) -// CHECK-NEXT: %34:2 = scf.for %arg0 = %c0 to %33 step %c1 iter_args(%arg1 = %32, %arg2 = %20) -> (i256, i256) { -// CHECK-NEXT: %51 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %52, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %54, %55 : i256, i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = arith.index_castui %19 : i256 to index loc(#loc1) +// CHECK-NEXT: %38:2 = scf.for %arg0 = %c0 to %37 step %c1 iter_args(%arg1 = %36, %arg2 = %20) -> (i256, i256) { +// CHECK-NEXT: %55 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %56, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %58, %59 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %35 = func.call @darr_88(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = llvm.load %36 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %39 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = func.call @darr_88(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %41, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = arith.index_castui %41 : i256 to index loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %37, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = arith.muli %41, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %44, %46 : i256 loc(#loc1) -// CHECK-NEXT: %48:2 = scf.for %arg0 = %c0 to %43 step %c1 iter_args(%arg1 = %44, %arg2 = %45) -> (i256, i256) { -// CHECK-NEXT: %51 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %52, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %54, %55 : i256, i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %41, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %45, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = arith.index_castui %45 : i256 to index loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %41, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %39, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %50 = arith.muli %45, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %48, %50 : i256 loc(#loc1) +// CHECK-NEXT: %52:2 = scf.for %arg0 = %c0 to %47 step %c1 iter_args(%arg1 = %48, %arg2 = %49) -> (i256, i256) { +// CHECK-NEXT: %55 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.load %55 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %57 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %56, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %58 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %59 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %58, %59 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %49 = arith.subi %47, %37 : i256 loc(#loc1) -// CHECK-NEXT: %50 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%50, %49) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %53 = arith.subi %51, %41 : i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%54, %53) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -605,243 +660,268 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%37, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%37, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %38, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %38, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %38, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %38, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %38, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %38, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %20 = arith.addi %19, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %20, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %13, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %1 : i256 loc(#loc1) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %19 : i256 loc(#loc1) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = arith.addi %35, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = arith.addi %35, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = arith.addi %35, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%45, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%39, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %24:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %19, %arg2 = %15) -> (i256, i256) { -// CHECK-NEXT: %34 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %36 { -// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = arith.addi %13, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.cmpi ugt, %25, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %38, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = arith.addi %38, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %38, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%48, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %27:2 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %19, %arg2 = %15) -> (i256, i256) { +// CHECK-NEXT: %37 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.cmpi ugt, %38, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %39 { +// CHECK-NEXT: %67 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %70 = arith.addi %68, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %72 = arith.addi %68, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = arith.addi %68, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %68, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%78, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %37 = arith.addi %15, %35 : i256 loc(#loc1) -// CHECK-NEXT: %38 = arith.addi %37, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %39 = arith.cmpi sge, %38, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %39 { -// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %15, %38 : i256 loc(#loc1) +// CHECK-NEXT: %41 = arith.addi %40, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %42 = arith.cmpi sge, %41, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %42 { +// CHECK-NEXT: %67 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %70 = arith.addi %68, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %72 = arith.addi %68, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = arith.addi %68, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %68, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%78, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %37 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.muli %41, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %43 : i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.cmpi ugt, %44, %1 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %45 { -// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) -// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) -// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %40 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %40, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = arith.muli %44, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.addi %45, %46 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.cmpi ugt, %47, %1 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %48 { +// CHECK-NEXT: %67 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %70 = arith.addi %68, %c4_i256 : i256 loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %70 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %71 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %72 = arith.addi %68, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %73 = llvm.inttoptr %72 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %73 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %74 = arith.addi %68, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %75 = llvm.inttoptr %74 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %75 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %76 = arith.addi %68, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %77 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038843778210450001422163835187549121709092664183213130986509706461184_i256, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %78 = llvm.inttoptr %68 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%78, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %46 = arith.muli %41, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %47 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.if %47 { -// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%62, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %49 = arith.muli %44, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %50 = arith.cmpi ugt, %44, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.if %50 { +// CHECK-NEXT: %67 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %46, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %49 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %50, %48 : i256 loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %51, %52 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %41, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %54 = arith.addi %50, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %55 = arith.index_castui %41 : i256 to index loc(#loc1) -// CHECK-NEXT: %56:2 = scf.for %arg3 = %c0 to %55 step %c1 iter_args(%arg4 = %54, %arg5 = %42) -> (i256, i256) { -// CHECK-NEXT: %60 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) -// CHECK-NEXT: %62 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %61, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %64 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %63, %64 : i256, i256 loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %53 = arith.addi %49, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %54 = arith.andi %53, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %52, %54 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.cmpi ugt, %55, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = arith.cmpi ult, %55, %52 : i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.ori %56, %57 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %58 { +// CHECK-NEXT: %67 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %67 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%69, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %57 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %50, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %58 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %58, %59 : i256, i256 loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %55, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %44, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = arith.addi %52, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %62 = arith.index_castui %44 : i256 to index loc(#loc1) +// CHECK-NEXT: %63:2 = scf.for %arg3 = %c0 to %62 step %c1 iter_args(%arg4 = %61, %arg5 = %45) -> (i256, i256) { +// CHECK-NEXT: %67 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: %68 = llvm.load %67 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) +// CHECK-NEXT: %69 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %68, %69 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %70 = arith.addi %arg4, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %71 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %70, %71 : i256, i256 loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %64 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %52, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %65, %66 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %25 = func.call @darr2_104(%19) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %28 = arith.addi %27, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %29 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %27, %c96_i256 : i256 loc(#loc1) -// CHECK-NEXT: %31:3 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %28, %arg2 = %25, %arg3 = %30) -> (i256, i256, i256) { -// CHECK-NEXT: %34 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = llvm.load %34 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %36 = arith.subi %arg3, %28 : i256 loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %36, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = func.call @darr2_104(%19) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.addi %30, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %33 = arith.addi %30, %c96_i256 : i256 loc(#loc1) +// CHECK-NEXT: %34:3 = scf.for %arg0 = %c0 to %c2 step %c1 iter_args(%arg1 = %31, %arg2 = %28, %arg3 = %33) -> (i256, i256, i256) { +// CHECK-NEXT: %37 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %39 = arith.subi %arg3, %31 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %arg1 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %41 = arith.index_castui %39 : i256 to index loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %arg3, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %43 = arith.addi %35, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %44 = arith.muli %39, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %42, %44 : i256 loc(#loc1) -// CHECK-NEXT: %46:2 = scf.for %arg4 = %c0 to %41 step %c1 iter_args(%arg5 = %42, %arg6 = %43) -> (i256, i256) { -// CHECK-NEXT: %49 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = llvm.load %49 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %51 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %50, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %53 = arith.addi %arg6, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %52, %53 : i256, i256 loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %38 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %43 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %42, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %44 = arith.index_castui %42 : i256 to index loc(#loc1) +// CHECK-NEXT: %45 = arith.addi %arg3, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %38, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = arith.muli %42, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %45, %47 : i256 loc(#loc1) +// CHECK-NEXT: %49:2 = scf.for %arg4 = %c0 to %44 step %c1 iter_args(%arg5 = %45, %arg6 = %46) -> (i256, i256) { +// CHECK-NEXT: %52 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %53 = llvm.load %52 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %arg5 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %53, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %arg5, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.addi %arg6, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %55, %56 : i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %47 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: scf.yield %47, %48, %45 : i256, i256, i256 loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %arg1, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %51 = arith.addi %arg2, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: scf.yield %50, %51, %48 : i256, i256, i256 loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %32 = arith.subi %31#2, %27 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%33, %32) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %35 = arith.subi %34#2, %30 : i256 loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %30 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%36, %35) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -849,63 +929,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %55, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %55, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %55, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %55, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%65, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %55, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %55, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %55, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %55, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%65, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -914,74 +994,90 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %55, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %55, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %55, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %55, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%65, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%56, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%62, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @str_116(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %39, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %39, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%46, %47, %44) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %48 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %44, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %44, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %50 = arith.andi %49, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %42, %50 : i256 loc(#loc1) -// CHECK-NEXT: %52 = arith.subi %51, %39 : i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %52) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%62, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @str_116(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %43, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %43, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %41, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %50 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%50, %51, %48) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %48 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %48, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %48, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.andi %55, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = arith.addi %46, %56 : i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.subi %57, %43 : i256 loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%59, %58) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -1059,63 +1155,63 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%54, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%60, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %55, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %55, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %55, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %55, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%65, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %15 = arith.addi %13, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %16 = arith.addi %13, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.cmpi sge, %16, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %17 { -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %55, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %55, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %55, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %55, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%65, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %18 = llvm.inttoptr %15 : i256 to !llvm.ptr<2> loc(#loc1) @@ -1124,74 +1220,90 @@ contract C { // CHECK-NEXT: %21 = arith.addi %20, %19 : i256 loc(#loc1) // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %1 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %54 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.load %54 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %57 = arith.addi %55, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %58 = llvm.inttoptr %57 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %58 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %59 = arith.addi %55, %c36_i256 : i256 loc(#loc1) -// CHECK-NEXT: %60 = llvm.inttoptr %59 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %61 = arith.addi %55, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.load %60 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %62 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %63 = arith.addi %55, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %62 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %63 = arith.addi %61, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %64 = llvm.inttoptr %63 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %65 = llvm.inttoptr %55 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%65, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %64 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %65 = arith.addi %61, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %66 = llvm.inttoptr %65 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %66 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %67 = arith.addi %61, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %68 = llvm.inttoptr %67 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %68 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %69 = arith.addi %61, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %70 = llvm.inttoptr %69 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %70 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %71 = llvm.inttoptr %61 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%71, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23 = arith.addi %19, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %54 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %55 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %56 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%56, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%62, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %26 = arith.addi %24, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.addi %28, %26 : i256 loc(#loc1) -// CHECK-NEXT: %30 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %19, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = arith.addi %28, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%33, %34, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %35 = arith.addi %32, %19 : i256 loc(#loc1) -// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %37 = func.call @bts_156(%28) : (i256) -> i256 loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %40 = arith.addi %39, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %41 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = arith.addi %39, %c64_i256 : i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = llvm.load %43 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %45 = arith.addi %37, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %46 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %45 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memmove"(%46, %47, %44) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %48 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %44, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %49 = arith.addi %44, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %50 = arith.andi %49, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %51 = arith.addi %42, %50 : i256 loc(#loc1) -// CHECK-NEXT: %52 = arith.subi %51, %39 : i256 loc(#loc1) -// CHECK-NEXT: %53 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%53, %52) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.addi %24, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %27, %29 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %27 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %60 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %60 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %61 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %61 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %62 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%62, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %19, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = arith.addi %27, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %20 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%37, %38, %19) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %39 = arith.addi %36, %19 : i256 loc(#loc1) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %41 = func.call @bts_156(%27) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = arith.addi %43, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = arith.addi %43, %c64_i256 : i256 loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = llvm.load %47 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %49 = arith.addi %41, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %50 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %51 = llvm.inttoptr %49 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memmove"(%50, %51, %48) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %48 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %48, %54 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %55 = arith.addi %48, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %56 = arith.andi %55, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %57 = arith.addi %46, %56 : i256 loc(#loc1) +// CHECK-NEXT: %58 = arith.subi %57, %43 : i256 loc(#loc1) +// CHECK-NEXT: %59 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%59, %58) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } diff --git a/test/lit/mlirCodegen/EVM/getter.sol b/test/lit/mlirCodegen/EVM/getter.sol index a38226e0e..67d72470e 100644 --- a/test/lit/mlirCodegen/EVM/getter.sol +++ b/test/lit/mlirCodegen/EVM/getter.sol @@ -29,6 +29,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -37,8 +44,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_42"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -46,22 +53,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_42() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_42_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_42_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_42_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_42_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -144,8 +165,8 @@ contract C { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = func.call @get_str_10() : () -> i256 loc(#loc1) @@ -161,14 +182,17 @@ contract C { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } diff --git a/test/lit/mlirCodegen/EVM/immutable.sol b/test/lit/mlirCodegen/EVM/immutable.sol index 05381437c..fc73470c0 100644 --- a/test/lit/mlirCodegen/EVM/immutable.sol +++ b/test/lit/mlirCodegen/EVM/immutable.sol @@ -16,6 +16,13 @@ contract C { // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -24,8 +31,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_29"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -33,28 +40,42 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%30, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @_16() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_29_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_29_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %c128_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %19 = llvm.load %18 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: llvm.setimmutable %13, "i_2", %19 loc(#loc1) -// CHECK-NEXT: %20 = llvm.inttoptr %c160_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: llvm.setimmutable %13, "j_4", %21 loc(#loc1) -// CHECK-NEXT: %22 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%22, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_29_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_29_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %c128_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: llvm.setimmutable %18, "i_2", %24 loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c160_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: llvm.setimmutable %18, "j_4", %26 loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%27, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/indirect-call.sol b/test/lit/mlirCodegen/EVM/indirect-call.sol index 8371c3470..b93d52390 100644 --- a/test/lit/mlirCodegen/EVM/indirect-call.sol +++ b/test/lit/mlirCodegen/EVM/indirect-call.sol @@ -73,6 +73,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -81,8 +88,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_39"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -90,22 +97,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @D_39() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_39_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_39_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_39_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_39_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -255,6 +276,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -263,8 +291,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_274"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -272,22 +300,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_274() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_274_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_274_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_274_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_274_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -495,8 +537,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @callNonPure_273(%arg0: i256 loc({{.*}}:60:23)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) // CHECK-NEXT: %c4294967295_i256 = arith.constant 4294967295 : i256 loc(#loc) @@ -550,17 +597,43 @@ contract C { // CHECK-NEXT: %27 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc8) // CHECK-NEXT: %28 = arith.cmpi ult, %27, %c32_i256 : i256 loc(#loc8) // CHECK-NEXT: %29 = scf.if %28 -> (i256) { -// CHECK-NEXT: %34 = arith.addi %16, %27 : i256 loc(#loc8) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %36 = arith.addi %16, %27 : i256 loc(#loc8) -// CHECK-NEXT: scf.yield %36 : i256 loc(#loc8) +// CHECK-NEXT: %34 = arith.addi %27, %c31_i256 : i256 loc(#loc8) +// CHECK-NEXT: %35 = arith.andi %34, %c-32_i256 : i256 loc(#loc8) +// CHECK-NEXT: %36 = arith.addi %16, %35 : i256 loc(#loc8) +// CHECK-NEXT: %37 = arith.cmpi ugt, %36, %c18446744073709551615_i256 : i256 loc(#loc8) +// CHECK-NEXT: %38 = arith.cmpi ult, %36, %16 : i256 loc(#loc8) +// CHECK-NEXT: %39 = arith.ori %37, %38 : i1 loc(#loc8) +// CHECK-NEXT: scf.if %39 { +// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %36, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %41 = arith.addi %16, %27 : i256 loc(#loc8) +// CHECK-NEXT: scf.yield %41 : i256 loc(#loc8) // CHECK-NEXT: } else { // CHECK-NEXT: %34 = arith.addi %16, %c32_i256 : i256 loc(#loc8) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) -// CHECK-NEXT: %36 = arith.addi %16, %c32_i256 : i256 loc(#loc8) -// CHECK-NEXT: scf.yield %36 : i256 loc(#loc8) +// CHECK-NEXT: %35 = arith.cmpi ugt, %34, %c18446744073709551615_i256 : i256 loc(#loc8) +// CHECK-NEXT: %36 = arith.cmpi ult, %34, %16 : i256 loc(#loc8) +// CHECK-NEXT: %37 = arith.ori %35, %36 : i1 loc(#loc8) +// CHECK-NEXT: scf.if %37 { +// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %41 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %c65_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: "llvm.intrcall"(%42, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc8) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc8) +// CHECK-NEXT: } loc(#loc8) +// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: llvm.store %34, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc8) +// CHECK-NEXT: %39 = arith.addi %16, %c32_i256 : i256 loc(#loc8) +// CHECK-NEXT: scf.yield %39 : i256 loc(#loc8) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: %30 = arith.subi %29, %16 : i256 loc(#loc8) // CHECK-NEXT: %31 = arith.cmpi slt, %30, %c32_i256 : i256 loc(#loc8) @@ -578,8 +651,13 @@ contract C { // CHECK-NEXT: return %26 : i256 loc(#loc9) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: func.func @tryCallGas_245(%arg0: i256 loc({{.*}}:46:22)) -> (i1, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) // CHECK-NEXT: %c4294967295_i256 = arith.constant 4294967295 : i256 loc(#loc) @@ -627,17 +705,43 @@ contract C { // CHECK-NEXT: %31 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc17) // CHECK-NEXT: %32 = arith.cmpi ult, %31, %c32_i256 : i256 loc(#loc17) // CHECK-NEXT: %33 = scf.if %32 -> (i256) { -// CHECK-NEXT: %38 = arith.addi %17, %31 : i256 loc(#loc17) -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %40 = arith.addi %17, %31 : i256 loc(#loc17) -// CHECK-NEXT: scf.yield %40 : i256 loc(#loc17) +// CHECK-NEXT: %38 = arith.addi %31, %c31_i256 : i256 loc(#loc17) +// CHECK-NEXT: %39 = arith.andi %38, %c-32_i256 : i256 loc(#loc17) +// CHECK-NEXT: %40 = arith.addi %17, %39 : i256 loc(#loc17) +// CHECK-NEXT: %41 = arith.cmpi ugt, %40, %c18446744073709551615_i256 : i256 loc(#loc17) +// CHECK-NEXT: %42 = arith.cmpi ult, %40, %17 : i256 loc(#loc17) +// CHECK-NEXT: %43 = arith.ori %41, %42 : i1 loc(#loc17) +// CHECK-NEXT: scf.if %43 { +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c65_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc17) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc17) +// CHECK-NEXT: } loc(#loc17) +// CHECK-NEXT: %44 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %40, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %45 = arith.addi %17, %31 : i256 loc(#loc17) +// CHECK-NEXT: scf.yield %45 : i256 loc(#loc17) // CHECK-NEXT: } else { // CHECK-NEXT: %38 = arith.addi %17, %c32_i256 : i256 loc(#loc17) -// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %38, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %40 = arith.addi %17, %c32_i256 : i256 loc(#loc17) -// CHECK-NEXT: scf.yield %40 : i256 loc(#loc17) +// CHECK-NEXT: %39 = arith.cmpi ugt, %38, %c18446744073709551615_i256 : i256 loc(#loc17) +// CHECK-NEXT: %40 = arith.cmpi ult, %38, %17 : i256 loc(#loc17) +// CHECK-NEXT: %41 = arith.ori %39, %40 : i1 loc(#loc17) +// CHECK-NEXT: scf.if %41 { +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %44 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %45 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c65_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: "llvm.intrcall"(%46, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc17) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc17) +// CHECK-NEXT: } loc(#loc17) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %38, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %43 = arith.addi %17, %c32_i256 : i256 loc(#loc17) +// CHECK-NEXT: scf.yield %43 : i256 loc(#loc17) // CHECK-NEXT: } loc(#loc17) // CHECK-NEXT: %34 = arith.subi %33, %17 : i256 loc(#loc17) // CHECK-NEXT: %35 = arith.cmpi slt, %34, %c32_i256 : i256 loc(#loc17) @@ -670,8 +774,13 @@ contract C { // CHECK-NEXT: return %29, %30 : i1, i256 loc(#loc26) // CHECK-NEXT: } loc(#loc10) // CHECK-NEXT: func.func @tryCall_185(%arg0: i256 loc({{.*}}:32:19)) -> (i1, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) // CHECK-NEXT: %c4294967295_i256 = arith.constant 4294967295 : i256 loc(#loc) @@ -719,17 +828,43 @@ contract C { // CHECK-NEXT: %32 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc34) // CHECK-NEXT: %33 = arith.cmpi ult, %32, %c32_i256 : i256 loc(#loc34) // CHECK-NEXT: %34 = scf.if %33 -> (i256) { -// CHECK-NEXT: %39 = arith.addi %18, %32 : i256 loc(#loc34) -// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %41 = arith.addi %18, %32 : i256 loc(#loc34) -// CHECK-NEXT: scf.yield %41 : i256 loc(#loc34) +// CHECK-NEXT: %39 = arith.addi %32, %c31_i256 : i256 loc(#loc34) +// CHECK-NEXT: %40 = arith.andi %39, %c-32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %41 = arith.addi %18, %40 : i256 loc(#loc34) +// CHECK-NEXT: %42 = arith.cmpi ugt, %41, %c18446744073709551615_i256 : i256 loc(#loc34) +// CHECK-NEXT: %43 = arith.cmpi ult, %41, %18 : i256 loc(#loc34) +// CHECK-NEXT: %44 = arith.ori %42, %43 : i1 loc(#loc34) +// CHECK-NEXT: scf.if %44 { +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %48 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c65_i256, %48 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %49 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%49, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %41, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %46 = arith.addi %18, %32 : i256 loc(#loc34) +// CHECK-NEXT: scf.yield %46 : i256 loc(#loc34) // CHECK-NEXT: } else { // CHECK-NEXT: %39 = arith.addi %18, %c32_i256 : i256 loc(#loc34) -// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %41 = arith.addi %18, %c32_i256 : i256 loc(#loc34) -// CHECK-NEXT: scf.yield %41 : i256 loc(#loc34) +// CHECK-NEXT: %40 = arith.cmpi ugt, %39, %c18446744073709551615_i256 : i256 loc(#loc34) +// CHECK-NEXT: %41 = arith.cmpi ult, %39, %18 : i256 loc(#loc34) +// CHECK-NEXT: %42 = arith.ori %40, %41 : i1 loc(#loc34) +// CHECK-NEXT: scf.if %42 { +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %43 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %39, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %44 = arith.addi %18, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: scf.yield %44 : i256 loc(#loc34) // CHECK-NEXT: } loc(#loc34) // CHECK-NEXT: %35 = arith.subi %34, %18 : i256 loc(#loc34) // CHECK-NEXT: %36 = arith.cmpi slt, %35, %c32_i256 : i256 loc(#loc34) @@ -762,8 +897,13 @@ contract C { // CHECK-NEXT: return %30, %31 : i1, i256 loc(#loc43) // CHECK-NEXT: } loc(#loc27) // CHECK-NEXT: func.func @callGas_127(%arg0: i256 loc({{.*}}:27:19)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) // CHECK-NEXT: %c4294967295_i256 = arith.constant 4294967295 : i256 loc(#loc) @@ -817,17 +957,43 @@ contract C { // CHECK-NEXT: %26 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc49) // CHECK-NEXT: %27 = arith.cmpi ult, %26, %c32_i256 : i256 loc(#loc49) // CHECK-NEXT: %28 = scf.if %27 -> (i256) { -// CHECK-NEXT: %33 = arith.addi %15, %26 : i256 loc(#loc49) -// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %35 = arith.addi %15, %26 : i256 loc(#loc49) -// CHECK-NEXT: scf.yield %35 : i256 loc(#loc49) +// CHECK-NEXT: %33 = arith.addi %26, %c31_i256 : i256 loc(#loc49) +// CHECK-NEXT: %34 = arith.andi %33, %c-32_i256 : i256 loc(#loc49) +// CHECK-NEXT: %35 = arith.addi %15, %34 : i256 loc(#loc49) +// CHECK-NEXT: %36 = arith.cmpi ugt, %35, %c18446744073709551615_i256 : i256 loc(#loc49) +// CHECK-NEXT: %37 = arith.cmpi ult, %35, %15 : i256 loc(#loc49) +// CHECK-NEXT: %38 = arith.ori %36, %37 : i1 loc(#loc49) +// CHECK-NEXT: scf.if %38 { +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc49) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc49) +// CHECK-NEXT: } loc(#loc49) +// CHECK-NEXT: %39 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: llvm.store %35, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: %40 = arith.addi %15, %26 : i256 loc(#loc49) +// CHECK-NEXT: scf.yield %40 : i256 loc(#loc49) // CHECK-NEXT: } else { // CHECK-NEXT: %33 = arith.addi %15, %c32_i256 : i256 loc(#loc49) -// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %35 = arith.addi %15, %c32_i256 : i256 loc(#loc49) -// CHECK-NEXT: scf.yield %35 : i256 loc(#loc49) +// CHECK-NEXT: %34 = arith.cmpi ugt, %33, %c18446744073709551615_i256 : i256 loc(#loc49) +// CHECK-NEXT: %35 = arith.cmpi ult, %33, %15 : i256 loc(#loc49) +// CHECK-NEXT: %36 = arith.ori %34, %35 : i1 loc(#loc49) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: %40 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: llvm.store %c65_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: "llvm.intrcall"(%41, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc49) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc49) +// CHECK-NEXT: } loc(#loc49) +// CHECK-NEXT: %37 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: llvm.store %33, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: %38 = arith.addi %15, %c32_i256 : i256 loc(#loc49) +// CHECK-NEXT: scf.yield %38 : i256 loc(#loc49) // CHECK-NEXT: } loc(#loc49) // CHECK-NEXT: %29 = arith.subi %28, %15 : i256 loc(#loc49) // CHECK-NEXT: %30 = arith.cmpi slt, %29, %c32_i256 : i256 loc(#loc49) @@ -845,8 +1011,13 @@ contract C { // CHECK-NEXT: return %25 : i256 loc(#loc50) // CHECK-NEXT: } loc(#loc44) // CHECK-NEXT: func.func @call_102(%arg0: i256 loc({{.*}}:22:16)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) // CHECK-NEXT: %c4294967295_i256 = arith.constant 4294967295 : i256 loc(#loc) @@ -900,17 +1071,43 @@ contract C { // CHECK-NEXT: %27 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc56) // CHECK-NEXT: %28 = arith.cmpi ult, %27, %c32_i256 : i256 loc(#loc56) // CHECK-NEXT: %29 = scf.if %28 -> (i256) { -// CHECK-NEXT: %34 = arith.addi %16, %27 : i256 loc(#loc56) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc56) -// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) -// CHECK-NEXT: %36 = arith.addi %16, %27 : i256 loc(#loc56) -// CHECK-NEXT: scf.yield %36 : i256 loc(#loc56) +// CHECK-NEXT: %34 = arith.addi %27, %c31_i256 : i256 loc(#loc56) +// CHECK-NEXT: %35 = arith.andi %34, %c-32_i256 : i256 loc(#loc56) +// CHECK-NEXT: %36 = arith.addi %16, %35 : i256 loc(#loc56) +// CHECK-NEXT: %37 = arith.cmpi ugt, %36, %c18446744073709551615_i256 : i256 loc(#loc56) +// CHECK-NEXT: %38 = arith.cmpi ult, %36, %16 : i256 loc(#loc56) +// CHECK-NEXT: %39 = arith.ori %37, %38 : i1 loc(#loc56) +// CHECK-NEXT: scf.if %39 { +// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: %43 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: llvm.store %c65_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: %44 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: "llvm.intrcall"(%44, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc56) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc56) +// CHECK-NEXT: } loc(#loc56) +// CHECK-NEXT: %40 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: llvm.store %36, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: %41 = arith.addi %16, %27 : i256 loc(#loc56) +// CHECK-NEXT: scf.yield %41 : i256 loc(#loc56) // CHECK-NEXT: } else { // CHECK-NEXT: %34 = arith.addi %16, %c32_i256 : i256 loc(#loc56) -// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc56) -// CHECK-NEXT: llvm.store %34, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) -// CHECK-NEXT: %36 = arith.addi %16, %c32_i256 : i256 loc(#loc56) -// CHECK-NEXT: scf.yield %36 : i256 loc(#loc56) +// CHECK-NEXT: %35 = arith.cmpi ugt, %34, %c18446744073709551615_i256 : i256 loc(#loc56) +// CHECK-NEXT: %36 = arith.cmpi ult, %34, %16 : i256 loc(#loc56) +// CHECK-NEXT: %37 = arith.ori %35, %36 : i1 loc(#loc56) +// CHECK-NEXT: scf.if %37 { +// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: %41 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: llvm.store %c65_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: %42 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: "llvm.intrcall"(%42, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc56) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc56) +// CHECK-NEXT: } loc(#loc56) +// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: llvm.store %34, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc56) +// CHECK-NEXT: %39 = arith.addi %16, %c32_i256 : i256 loc(#loc56) +// CHECK-NEXT: scf.yield %39 : i256 loc(#loc56) // CHECK-NEXT: } loc(#loc56) // CHECK-NEXT: %30 = arith.subi %29, %16 : i256 loc(#loc56) // CHECK-NEXT: %31 = arith.cmpi slt, %30, %c32_i256 : i256 loc(#loc56) diff --git a/test/lit/mlirCodegen/EVM/inheritance.sol b/test/lit/mlirCodegen/EVM/inheritance.sol index f7bbf92a7..2396ebbec 100644 --- a/test/lit/mlirCodegen/EVM/inheritance.sol +++ b/test/lit/mlirCodegen/EVM/inheritance.sol @@ -24,6 +24,13 @@ contract C0 is C1 { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -32,8 +39,8 @@ contract C0 is C1 { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C1_44"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -41,22 +48,36 @@ contract C0 is C1 { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @_10() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C1_44_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C1_44_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C1_44_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C1_44_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -216,6 +237,13 @@ contract C0 is C1 { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -224,8 +252,8 @@ contract C0 is C1 { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C0_94"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -233,22 +261,36 @@ contract C0 is C1 { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @_54() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C0_94_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C0_94_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C0_94_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C0_94_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/inline-asm.sol b/test/lit/mlirCodegen/EVM/inline-asm.sol index b66a32361..1cc601dcb 100644 --- a/test/lit/mlirCodegen/EVM/inline-asm.sol +++ b/test/lit/mlirCodegen/EVM/inline-asm.sol @@ -37,6 +37,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -45,8 +52,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_54"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -54,22 +61,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_54() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_54_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_54_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_54_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_54_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/interface.sol b/test/lit/mlirCodegen/EVM/interface.sol index b09cadded..9f8f1193a 100644 --- a/test/lit/mlirCodegen/EVM/interface.sol +++ b/test/lit/mlirCodegen/EVM/interface.sol @@ -19,6 +19,13 @@ contract C is I, A { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -27,8 +34,8 @@ contract C is I, A { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_30"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -36,22 +43,36 @@ contract C is I, A { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_30() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_30_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_30_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_30_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_30_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/library.sol b/test/lit/mlirCodegen/EVM/library.sol index fcd7f48d5..9dc588f1e 100644 --- a/test/lit/mlirCodegen/EVM/library.sol +++ b/test/lit/mlirCodegen/EVM/library.sol @@ -205,6 +205,13 @@ contract C { // CHECK-NEXT: #loc4 = loc({{.*}}:5:13) // CHECK-NEXT: module @C_51 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -213,8 +220,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_51"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -222,22 +229,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_51() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_51_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_51_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_51_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_51_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/literals.sol b/test/lit/mlirCodegen/EVM/literals.sol index e23a0dfcf..83dc4d27d 100644 --- a/test/lit/mlirCodegen/EVM/literals.sol +++ b/test/lit/mlirCodegen/EVM/literals.sol @@ -26,6 +26,13 @@ contract Test { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -34,8 +41,8 @@ contract Test { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Test_28"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -43,27 +50,42 @@ contract Test { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @Test_28() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Test_28_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Test_28_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Test_28_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Test_28_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: llvm.mlir.global private unnamed_addr constant @__data_in_code__0("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddy") {addr_space = 4 : i32} loc(#loc2) // CHECK-NEXT: func.func @Test_28() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) // CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) // CHECK-NEXT: %c-1_i256 = arith.constant -1 : i256 loc(#loc) // CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) @@ -71,130 +93,143 @@ contract Test { // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) -// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c127_i256 = arith.constant 127 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.addressof @__data_in_code__0 : !llvm.ptr<4> loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c129_i256 = arith.constant 129 : i256 loc(#loc2) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) -// CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc2) // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) // CHECK-NEXT: %3 = arith.addi %2, %c192_i256 : i256 loc(#loc2) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: llvm.store %c129_i256, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %6 = llvm.ptrtoint %0 : !llvm.ptr<4> to i256 loc(#loc2) -// CHECK-NEXT: %7 = arith.addi %2, %c32_i256 : i256 loc(#loc2) -// CHECK-NEXT: %8 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<4> loc(#loc2) -// CHECK-NEXT: "llvm.intr.memcpy"(%8, %9, %c129_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) -// CHECK-NEXT: %10 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) -// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc3) -// CHECK-NEXT: %14 = arith.shrui %13, %c1_i256 : i256 loc(#loc3) -// CHECK-NEXT: %15 = arith.andi %13, %c1_i256 : i256 loc(#loc3) -// CHECK-NEXT: %16 = arith.cmpi eq, %15, %c0_i256 : i256 loc(#loc3) -// CHECK-NEXT: %17 = arith.andi %14, %c127_i256 : i256 loc(#loc3) -// CHECK-NEXT: %18 = arith.select %16, %17, %14 : i256 loc(#loc3) -// CHECK-NEXT: %19 = arith.cmpi ult, %18, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %20 = arith.trunci %15 : i256 to i1 loc(#loc3) -// CHECK-NEXT: %21 = arith.cmpi eq, %20, %19 : i1 loc(#loc3) -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %c34_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc3) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc2) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc2) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc2) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c65_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %8 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c129_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %9 = llvm.ptrtoint %0 : !llvm.ptr<4> to i256 loc(#loc2) +// CHECK-NEXT: %10 = arith.addi %2, %c32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %12 = llvm.inttoptr %9 : i256 to !llvm.ptr<4> loc(#loc2) +// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %c129_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) +// CHECK-NEXT: %13 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc3) +// CHECK-NEXT: %17 = arith.shrui %16, %c1_i256 : i256 loc(#loc3) +// CHECK-NEXT: %18 = arith.andi %16, %c1_i256 : i256 loc(#loc3) +// CHECK-NEXT: %19 = arith.cmpi eq, %18, %c0_i256 : i256 loc(#loc3) +// CHECK-NEXT: %20 = arith.andi %17, %c127_i256 : i256 loc(#loc3) +// CHECK-NEXT: %21 = arith.select %19, %20, %17 : i256 loc(#loc3) +// CHECK-NEXT: %22 = arith.cmpi ult, %21, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %23 = arith.trunci %18 : i256 to i1 loc(#loc3) +// CHECK-NEXT: %24 = arith.cmpi eq, %23, %22 : i1 loc(#loc3) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c34_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc3) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc3) // CHECK-NEXT: } loc(#loc3) -// CHECK-NEXT: %22 = arith.cmpi ugt, %18, %c31_i256 : i256 loc(#loc3) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %c0_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %26 = "llvm.intrcall"(%25, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc3) -// CHECK-NEXT: %27 = arith.addi %11, %c31_i256 : i256 loc(#loc3) -// CHECK-NEXT: %28 = arith.divui %27, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %29 = arith.addi %26, %28 : i256 loc(#loc3) -// CHECK-NEXT: %30 = arith.cmpi ult, %11, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %31 = arith.select %30, %26, %29 : i256 loc(#loc3) -// CHECK-NEXT: %32 = arith.addi %18, %c31_i256 : i256 loc(#loc3) -// CHECK-NEXT: %33 = arith.divui %32, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %34 = arith.addi %26, %33 : i256 loc(#loc3) -// CHECK-NEXT: %35 = arith.index_castui %31 : i256 to index loc(#loc3) -// CHECK-NEXT: %36 = arith.index_castui %34 : i256 to index loc(#loc3) -// CHECK-NEXT: scf.for %arg0 = %35 to %36 step %c1 { -// CHECK-NEXT: %37 = arith.index_castui %arg0 : index to i256 loc(#loc3) -// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<5> loc(#loc3) -// CHECK-NEXT: llvm.store %c0_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: %25 = arith.cmpi ugt, %21, %c31_i256 : i256 loc(#loc3) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c0_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %29 = "llvm.intrcall"(%28, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc3) +// CHECK-NEXT: %30 = arith.addi %14, %c31_i256 : i256 loc(#loc3) +// CHECK-NEXT: %31 = arith.divui %30, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %32 = arith.addi %29, %31 : i256 loc(#loc3) +// CHECK-NEXT: %33 = arith.cmpi ult, %14, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %34 = arith.select %33, %29, %32 : i256 loc(#loc3) +// CHECK-NEXT: %35 = arith.addi %21, %c31_i256 : i256 loc(#loc3) +// CHECK-NEXT: %36 = arith.divui %35, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %37 = arith.addi %29, %36 : i256 loc(#loc3) +// CHECK-NEXT: %38 = arith.index_castui %34 : i256 to index loc(#loc3) +// CHECK-NEXT: %39 = arith.index_castui %37 : i256 to index loc(#loc3) +// CHECK-NEXT: scf.for %arg0 = %38 to %39 step %c1 { +// CHECK-NEXT: %40 = arith.index_castui %arg0 : index to i256 loc(#loc3) +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: llvm.store %c0_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) // CHECK-NEXT: } loc(#loc3) // CHECK-NEXT: } loc(#loc3) -// CHECK-NEXT: %23 = arith.cmpi ugt, %11, %c31_i256 : i256 loc(#loc3) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %c0_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %26 = "llvm.intrcall"(%25, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc3) -// CHECK-NEXT: %27 = arith.addi %2, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %28 = arith.andi %11, %c-32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %29 = arith.index_castui %28 : i256 to index loc(#loc3) -// CHECK-NEXT: scf.for %arg0 = %c0 to %29 step %c32 { -// CHECK-NEXT: %34 = arith.index_castui %arg0 : index to i256 loc(#loc3) -// CHECK-NEXT: %35 = arith.divui %34, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %36 = arith.addi %27, %34 : i256 loc(#loc3) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) -// CHECK-NEXT: %39 = arith.addi %26, %35 : i256 loc(#loc3) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<5> loc(#loc3) -// CHECK-NEXT: llvm.store %38, %40 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: %26 = arith.cmpi ugt, %14, %c31_i256 : i256 loc(#loc3) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c0_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %29 = "llvm.intrcall"(%28, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc3) +// CHECK-NEXT: %30 = arith.addi %2, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %31 = arith.andi %14, %c-32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %32 = arith.index_castui %31 : i256 to index loc(#loc3) +// CHECK-NEXT: scf.for %arg0 = %c0 to %32 step %c32 { +// CHECK-NEXT: %37 = arith.index_castui %arg0 : index to i256 loc(#loc3) +// CHECK-NEXT: %38 = arith.divui %37, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %39 = arith.addi %30, %37 : i256 loc(#loc3) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) +// CHECK-NEXT: %42 = arith.addi %29, %38 : i256 loc(#loc3) +// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: llvm.store %41, %43 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) // CHECK-NEXT: } loc(#loc3) -// CHECK-NEXT: %30 = arith.cmpi ult, %28, %11 : i256 loc(#loc3) -// CHECK-NEXT: scf.if %30 { -// CHECK-NEXT: %34 = arith.andi %11, %c31_i256 : i256 loc(#loc3) -// CHECK-NEXT: %35 = arith.divui %28, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %36 = arith.addi %27, %28 : i256 loc(#loc3) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) -// CHECK-NEXT: %39 = arith.muli %34, %c8_i256 : i256 loc(#loc3) -// CHECK-NEXT: %40 = arith.subi %c256_i256, %39 : i256 loc(#loc3) -// CHECK-NEXT: %41 = arith.shli %c-1_i256, %40 : i256 loc(#loc3) -// CHECK-NEXT: %42 = arith.andi %38, %41 : i256 loc(#loc3) -// CHECK-NEXT: %43 = arith.addi %26, %35 : i256 loc(#loc3) -// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<5> loc(#loc3) -// CHECK-NEXT: llvm.store %42, %44 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %14 : i256 loc(#loc3) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %37 = arith.andi %14, %c31_i256 : i256 loc(#loc3) +// CHECK-NEXT: %38 = arith.divui %31, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %39 = arith.addi %30, %31 : i256 loc(#loc3) +// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %41 = llvm.load %40 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) +// CHECK-NEXT: %42 = arith.muli %37, %c8_i256 : i256 loc(#loc3) +// CHECK-NEXT: %43 = arith.subi %c256_i256, %42 : i256 loc(#loc3) +// CHECK-NEXT: %44 = arith.shli %c-1_i256, %43 : i256 loc(#loc3) +// CHECK-NEXT: %45 = arith.andi %41, %44 : i256 loc(#loc3) +// CHECK-NEXT: %46 = arith.addi %29, %38 : i256 loc(#loc3) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: llvm.store %45, %47 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) // CHECK-NEXT: } loc(#loc3) -// CHECK-NEXT: %31 = arith.muli %11, %c2_i256 : i256 loc(#loc3) -// CHECK-NEXT: %32 = arith.ori %31, %c1_i256 : i256 loc(#loc3) -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) -// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: %34 = arith.muli %14, %c2_i256 : i256 loc(#loc3) +// CHECK-NEXT: %35 = arith.ori %34, %c1_i256 : i256 loc(#loc3) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: llvm.store %35, %36 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) // CHECK-NEXT: } else { -// CHECK-NEXT: %24 = arith.cmpi ne, %11, %c0_i256 : i256 loc(#loc3) -// CHECK-NEXT: scf.if %24 { -// CHECK-NEXT: %25 = arith.addi %2, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %26 = llvm.inttoptr %25 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) -// CHECK-NEXT: %28 = arith.muli %11, %c8_i256 : i256 loc(#loc3) -// CHECK-NEXT: %29 = arith.subi %c256_i256, %28 : i256 loc(#loc3) -// CHECK-NEXT: %30 = arith.shli %c-1_i256, %29 : i256 loc(#loc3) -// CHECK-NEXT: %31 = arith.andi %27, %30 : i256 loc(#loc3) -// CHECK-NEXT: %32 = arith.muli %11, %c2_i256 : i256 loc(#loc3) -// CHECK-NEXT: %33 = arith.ori %31, %32 : i256 loc(#loc3) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) -// CHECK-NEXT: llvm.store %33, %34 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: %27 = arith.cmpi ne, %14, %c0_i256 : i256 loc(#loc3) +// CHECK-NEXT: scf.if %27 { +// CHECK-NEXT: %28 = arith.addi %2, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) +// CHECK-NEXT: %31 = arith.muli %14, %c8_i256 : i256 loc(#loc3) +// CHECK-NEXT: %32 = arith.subi %c256_i256, %31 : i256 loc(#loc3) +// CHECK-NEXT: %33 = arith.shli %c-1_i256, %32 : i256 loc(#loc3) +// CHECK-NEXT: %34 = arith.andi %30, %33 : i256 loc(#loc3) +// CHECK-NEXT: %35 = arith.muli %14, %c2_i256 : i256 loc(#loc3) +// CHECK-NEXT: %36 = arith.ori %34, %35 : i256 loc(#loc3) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: llvm.store %36, %37 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) // CHECK-NEXT: } else { -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) -// CHECK-NEXT: llvm.store %c0_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc3) +// CHECK-NEXT: llvm.store %c0_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc3) // CHECK-NEXT: } loc(#loc3) // CHECK-NEXT: } loc(#loc3) // CHECK-NEXT: return loc(#loc1) @@ -226,8 +261,8 @@ contract Test { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = func.call @i1_15() : () -> i256 loc(#loc1) @@ -243,14 +278,17 @@ contract Test { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -258,8 +296,8 @@ contract Test { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = func.call @i2_27() : () -> i256 loc(#loc1) @@ -275,14 +313,17 @@ contract Test { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -297,49 +338,85 @@ contract Test { // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: llvm.mlir.global private unnamed_addr constant @__data_in_code__1("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddx") {addr_space = 4 : i32} loc(#loc4) // CHECK-NEXT: func.func @i2_27() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.addressof @__data_in_code__1 : !llvm.ptr<4> loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c129_i256 = arith.constant 129 : i256 loc(#loc4) -// CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc4) // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc4) // CHECK-NEXT: %3 = arith.addi %2, %c192_i256 : i256 loc(#loc4) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: llvm.store %c129_i256, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %6 = llvm.ptrtoint %0 : !llvm.ptr<4> to i256 loc(#loc4) -// CHECK-NEXT: %7 = arith.addi %2, %c32_i256 : i256 loc(#loc4) -// CHECK-NEXT: %8 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<4> loc(#loc4) -// CHECK-NEXT: "llvm.intr.memcpy"(%8, %9, %c129_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc4) -// CHECK-NEXT: %10 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc6) -// CHECK-NEXT: llvm.store %2, %10 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc6) -// CHECK-NEXT: %11 = llvm.load %10 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc7) -// CHECK-NEXT: return %11 : i256 loc(#loc8) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc4) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %8 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c129_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %9 = llvm.ptrtoint %0 : !llvm.ptr<4> to i256 loc(#loc4) +// CHECK-NEXT: %10 = arith.addi %2, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %12 = llvm.inttoptr %9 : i256 to !llvm.ptr<4> loc(#loc4) +// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %c129_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc4) +// CHECK-NEXT: %13 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc6) +// CHECK-NEXT: llvm.store %2, %13 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc6) +// CHECK-NEXT: %14 = llvm.load %13 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc7) +// CHECK-NEXT: return %14 : i256 loc(#loc8) // CHECK-NEXT: } loc(#loc5) // CHECK-NEXT: func.func @i1_15() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c47219736118171679016481614208494153725245902603978864281390662590579859259392_i256 = arith.constant 47219736118171679016481614208494153725245902603978864281390662590579859259392 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c5_i256 = arith.constant 5 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc10) // CHECK-NEXT: %2 = arith.addi %1, %c64_i256 : i256 loc(#loc10) -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %2, %3 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %4 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c5_i256, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %5 = arith.addi %1, %c32_i256 : i256 loc(#loc10) -// CHECK-NEXT: %6 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: llvm.store %c47219736118171679016481614208494153725245902603978864281390662590579859259392_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) -// CHECK-NEXT: %7 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc11) -// CHECK-NEXT: llvm.store %1, %7 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc11) -// CHECK-NEXT: %8 = llvm.load %7 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc12) -// CHECK-NEXT: return %8 : i256 loc(#loc13) +// CHECK-NEXT: %3 = arith.cmpi ugt, %2, %c18446744073709551615_i256 : i256 loc(#loc10) +// CHECK-NEXT: %4 = arith.cmpi ult, %2, %1 : i256 loc(#loc10) +// CHECK-NEXT: %5 = arith.ori %3, %4 : i1 loc(#loc10) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c65_i256, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: "llvm.intrcall"(%14, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc10) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc10) +// CHECK-NEXT: } loc(#loc10) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %2, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %7 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c5_i256, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc10) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: llvm.store %c47219736118171679016481614208494153725245902603978864281390662590579859259392_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc10) +// CHECK-NEXT: %10 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc11) +// CHECK-NEXT: llvm.store %1, %10 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc11) +// CHECK-NEXT: %11 = llvm.load %10 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc12) +// CHECK-NEXT: return %11 : i256 loc(#loc13) // CHECK-NEXT: } loc(#loc9) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/magic.sol b/test/lit/mlirCodegen/EVM/magic.sol index 941066837..6dc60c403 100644 --- a/test/lit/mlirCodegen/EVM/magic.sol +++ b/test/lit/mlirCodegen/EVM/magic.sol @@ -16,6 +16,10 @@ function decode(bytes memory a) returns (uint, uint8, int32) { return abi.decode(a, (uint, uint8, int32)); } +function decode_calldata(bytes calldata a) returns (uint, uint8, int32) { + return abi.decode(a, (uint, uint8, int32)); +} + function encode_packed(uint24 x, uint96 y, uint136 z) returns (bytes memory) { return abi.encodePacked(x, y, z); } @@ -28,6 +32,10 @@ function decode_addr(bytes memory a) returns (address) { return abi.decode(a, (address)); } +function decode_addr_calldata(bytes calldata a) returns (address) { + return abi.decode(a, (address)); +} + function encode_packed_addr(address a) returns (bytes memory) { return abi.encodePacked(a); } @@ -60,6 +68,10 @@ function decode_contract(bytes memory data) returns (CC) { return abi.decode(data, (CC)); } +function decode_contract_calldata(bytes calldata data) returns (CC) { + return abi.decode(data, (CC)); +} + function roundtrip_contract(CC c) returns (CC) { return abi.decode(abi.encode(c), (CC)); } @@ -68,6 +80,10 @@ function decode_contract_tuple(bytes memory data) returns (CC, uint256) { return abi.decode(data, (CC, uint256)); } +function decode_contract_tuple_calldata(bytes calldata data) returns (CC, uint256) { + return abi.decode(data, (CC, uint256)); +} + enum E { A, B, C } function encode_packed_array_signed(int8[] memory x) returns (bytes memory) { @@ -142,6 +158,10 @@ function encode_array_calldata_nested_unsigned(uint8[][] calldata x) returns (by return abi.encode(x); } +function enc_nested(uint256[2][3] calldata x) returns (bytes memory) { + return abi.encode(x); +} + function encode_array_calldata_bool(bool[] calldata x) returns (bytes memory) { return abi.encode(x); } @@ -204,53 +224,65 @@ contract StorageBytes { // CHECK-NEXT: #loc10 = loc({{.*}}:10:16) // CHECK-NEXT: #loc11 = loc({{.*}}:10:25) // CHECK-NEXT: #loc12 = loc({{.*}}:10:36) -// CHECK-NEXT: #loc19 = loc({{.*}}:14:16) -// CHECK-NEXT: #loc23 = loc({{.*}}:18:23) -// CHECK-NEXT: #loc24 = loc({{.*}}:18:33) -// CHECK-NEXT: #loc25 = loc({{.*}}:18:43) -// CHECK-NEXT: #loc32 = loc({{.*}}:22:21) +// CHECK-NEXT: #loc18 = loc({{.*}}:14:16) +// CHECK-NEXT: #loc23 = loc({{.*}}:18:25) +// CHECK-NEXT: #loc28 = loc({{.*}}:22:23) +// CHECK-NEXT: #loc29 = loc({{.*}}:22:33) +// CHECK-NEXT: #loc30 = loc({{.*}}:22:43) // CHECK-NEXT: #loc37 = loc({{.*}}:26:21) -// CHECK-NEXT: #loc42 = loc({{.*}}:30:28) -// CHECK-NEXT: #loc47 = loc({{.*}}:34:24) -// CHECK-NEXT: #loc53 = loc({{.*}}:38:30) -// CHECK-NEXT: #loc54 = loc({{.*}}:38:41) -// CHECK-NEXT: #loc61 = loc({{.*}}:42:32) -// CHECK-NEXT: #loc67 = loc({{.*}}:50:25) -// CHECK-NEXT: #loc72 = loc({{.*}}:54:32) +// CHECK-NEXT: #loc42 = loc({{.*}}:30:21) +// CHECK-NEXT: #loc47 = loc({{.*}}:34:30) +// CHECK-NEXT: #loc52 = loc({{.*}}:38:28) +// CHECK-NEXT: #loc57 = loc({{.*}}:42:24) +// CHECK-NEXT: #loc63 = loc({{.*}}:46:30) +// CHECK-NEXT: #loc64 = loc({{.*}}:46:41) +// CHECK-NEXT: #loc71 = loc({{.*}}:50:32) // CHECK-NEXT: #loc77 = loc({{.*}}:58:25) -// CHECK-NEXT: #loc82 = loc({{.*}}:62:28) -// CHECK-NEXT: #loc88 = loc({{.*}}:66:31) -// CHECK-NEXT: #loc93 = loc({{.*}}:72:36) -// CHECK-NEXT: #loc98 = loc({{.*}}:76:38) -// CHECK-NEXT: #loc103 = loc({{.*}}:80:34) -// CHECK-NEXT: #loc108 = loc({{.*}}:84:34) -// CHECK-NEXT: #loc113 = loc({{.*}}:88:37) -// CHECK-NEXT: #loc118 = loc({{.*}}:92:40) -// CHECK-NEXT: #loc123 = loc({{.*}}:96:45) -// CHECK-NEXT: #loc128 = loc({{.*}}:100:47) -// CHECK-NEXT: #loc133 = loc({{.*}}:104:43) -// CHECK-NEXT: #loc138 = loc({{.*}}:108:43) -// CHECK-NEXT: #loc143 = loc({{.*}}:112:46) +// CHECK-NEXT: #loc82 = loc({{.*}}:62:32) +// CHECK-NEXT: #loc87 = loc({{.*}}:66:25) +// CHECK-NEXT: #loc92 = loc({{.*}}:70:34) +// CHECK-NEXT: #loc97 = loc({{.*}}:74:28) +// CHECK-NEXT: #loc103 = loc({{.*}}:78:31) +// CHECK-NEXT: #loc108 = loc({{.*}}:82:40) +// CHECK-NEXT: #loc113 = loc({{.*}}:88:36) +// CHECK-NEXT: #loc118 = loc({{.*}}:92:38) +// CHECK-NEXT: #loc123 = loc({{.*}}:96:34) +// CHECK-NEXT: #loc128 = loc({{.*}}:100:34) +// CHECK-NEXT: #loc133 = loc({{.*}}:104:37) +// CHECK-NEXT: #loc138 = loc({{.*}}:108:40) +// CHECK-NEXT: #loc143 = loc({{.*}}:112:45) // CHECK-NEXT: #loc148 = loc({{.*}}:116:47) -// CHECK-NEXT: #loc153 = loc({{.*}}:120:21) -// CHECK-NEXT: #loc158 = loc({{.*}}:124:22) -// CHECK-NEXT: #loc163 = loc({{.*}}:128:21) -// CHECK-NEXT: #loc168 = loc({{.*}}:132:23) -// CHECK-NEXT: #loc173 = loc({{.*}}:136:40) -// CHECK-NEXT: #loc178 = loc({{.*}}:140:47) -// CHECK-NEXT: #loc183 = loc({{.*}}:144:36) -// CHECK-NEXT: #loc188 = loc({{.*}}:148:36) -// CHECK-NEXT: #loc193 = loc({{.*}}:152:39) -// CHECK-NEXT: #loc198 = loc({{.*}}:156:40) -// CHECK-NEXT: #loc203 = loc({{.*}}:160:45) -// CHECK-NEXT: #loc208 = loc({{.*}}:164:38) -// CHECK-NEXT: #loc213 = loc({{.*}}:168:25) -// CHECK-NEXT: #loc214 = loc({{.*}}:168:37) -// CHECK-NEXT: #loc220 = loc({{.*}}:172:22) -// CHECK-NEXT: #loc225 = loc({{.*}}:176:29) -// CHECK-NEXT: #loc230 = loc({{.*}}:180:35) -// CHECK-NEXT: module @CC_196 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: #loc153 = loc({{.*}}:120:43) +// CHECK-NEXT: #loc158 = loc({{.*}}:124:43) +// CHECK-NEXT: #loc163 = loc({{.*}}:128:46) +// CHECK-NEXT: #loc168 = loc({{.*}}:132:47) +// CHECK-NEXT: #loc173 = loc({{.*}}:136:21) +// CHECK-NEXT: #loc178 = loc({{.*}}:140:22) +// CHECK-NEXT: #loc183 = loc({{.*}}:144:21) +// CHECK-NEXT: #loc188 = loc({{.*}}:148:23) +// CHECK-NEXT: #loc193 = loc({{.*}}:152:40) +// CHECK-NEXT: #loc198 = loc({{.*}}:156:47) +// CHECK-NEXT: #loc203 = loc({{.*}}:160:20) +// CHECK-NEXT: #loc208 = loc({{.*}}:164:36) +// CHECK-NEXT: #loc213 = loc({{.*}}:168:36) +// CHECK-NEXT: #loc218 = loc({{.*}}:172:39) +// CHECK-NEXT: #loc223 = loc({{.*}}:176:40) +// CHECK-NEXT: #loc228 = loc({{.*}}:180:45) +// CHECK-NEXT: #loc233 = loc({{.*}}:184:38) +// CHECK-NEXT: #loc238 = loc({{.*}}:188:25) +// CHECK-NEXT: #loc239 = loc({{.*}}:188:37) +// CHECK-NEXT: #loc245 = loc({{.*}}:192:22) +// CHECK-NEXT: #loc250 = loc({{.*}}:196:29) +// CHECK-NEXT: #loc255 = loc({{.*}}:200:35) +// CHECK-NEXT: module @CC_236 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -259,31 +291,45 @@ contract StorageBytes { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["CC_196"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["CC_236"], name = "evm.datasize"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %4 = "llvm.intrcall"() <{id = 4042 : i32, name = "evm.codesize"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: call @CC_196() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["CC_196_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["CC_196_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @CC_236() : () -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["CC_236_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["CC_236_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -301,6 +347,12 @@ contract StorageBytes { // CHECK-NEXT: func.func @encode_39(%arg0: i256 loc({{.*}}:10:16), %arg1: i8 loc({{.*}}:10:25), %arg2: i32 loc({{.*}}:10:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) @@ -313,408 +365,566 @@ contract StorageBytes { // CHECK-NEXT: %3 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc13) // CHECK-NEXT: %4 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i8 loc(#loc14) // CHECK-NEXT: %5 = llvm.load %2 {alignment = 32 : i64} : !llvm.ptr -> i32 loc(#loc15) -// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %9 = arith.addi %7, %c128_i256 : i256 loc(#loc16) -// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %11 = arith.addi %7, %c64_i256 : i256 loc(#loc16) -// CHECK-NEXT: %12 = arith.extui %4 : i8 to i256 loc(#loc16) -// CHECK-NEXT: %13 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %14 = arith.addi %7, %c96_i256 : i256 loc(#loc16) -// CHECK-NEXT: %15 = arith.extsi %5 : i32 to i256 loc(#loc16) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %17 = arith.subi %9, %8 : i256 loc(#loc16) -// CHECK-NEXT: %18 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %19 = arith.addi %7, %c128_i256 : i256 loc(#loc16) -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: return %7 : i256 loc(#loc17) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %9 = arith.addi %7, %c128_i256 : i256 loc(#loc2) +// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %11 = arith.addi %7, %c64_i256 : i256 loc(#loc2) +// CHECK-NEXT: %12 = arith.extui %4 : i8 to i256 loc(#loc2) +// CHECK-NEXT: %13 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %14 = arith.addi %7, %c96_i256 : i256 loc(#loc2) +// CHECK-NEXT: %15 = arith.extsi %5 : i32 to i256 loc(#loc2) +// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %17 = arith.subi %9, %8 : i256 loc(#loc2) +// CHECK-NEXT: %18 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %19 = arith.addi %7, %c128_i256 : i256 loc(#loc2) +// CHECK-NEXT: %20 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc2) +// CHECK-NEXT: %21 = arith.cmpi ult, %19, %7 : i256 loc(#loc2) +// CHECK-NEXT: %22 = arith.ori %20, %21 : i1 loc(#loc2) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %19, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: return %7 : i256 loc(#loc16) // CHECK-NEXT: } loc(#loc9) // CHECK-NEXT: func.func @decode_63(%arg0: i256 loc({{.*}}:14:16)) -> (i256, i8, i32) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc19) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc19) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc19) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc20) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc2) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c96_i256 : i256 loc(#loc2) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc18) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc18) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc18) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc19) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c96_i256 : i256 loc(#loc20) // CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) -// CHECK-NEXT: } loc(#loc2) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %8 = arith.addi %1, %c64_i256 : i256 loc(#loc2) -// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %11 = arith.trunci %10 : i256 to i8 loc(#loc2) -// CHECK-NEXT: %12 = arith.extui %11 : i8 to i256 loc(#loc2) -// CHECK-NEXT: %13 = arith.cmpi ne, %10, %12 : i256 loc(#loc2) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %8 = arith.addi %1, %c64_i256 : i256 loc(#loc20) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %11 = arith.trunci %10 : i256 to i8 loc(#loc20) +// CHECK-NEXT: %12 = arith.extui %11 : i8 to i256 loc(#loc20) +// CHECK-NEXT: %13 = arith.cmpi ne, %10, %12 : i256 loc(#loc20) // CHECK-NEXT: scf.if %13 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) -// CHECK-NEXT: } loc(#loc2) -// CHECK-NEXT: %14 = arith.addi %1, %c96_i256 : i256 loc(#loc2) -// CHECK-NEXT: %15 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %17 = arith.trunci %16 : i256 to i32 loc(#loc2) -// CHECK-NEXT: %18 = arith.extsi %17 : i32 to i256 loc(#loc2) -// CHECK-NEXT: %19 = arith.cmpi ne, %16, %18 : i256 loc(#loc2) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %14 = arith.addi %1, %c96_i256 : i256 loc(#loc20) +// CHECK-NEXT: %15 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %17 = arith.trunci %16 : i256 to i32 loc(#loc20) +// CHECK-NEXT: %18 = arith.extsi %17 : i32 to i256 loc(#loc20) +// CHECK-NEXT: %19 = arith.cmpi ne, %16, %18 : i256 loc(#loc20) // CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) -// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) // CHECK-NEXT: return %7, %11, %17 : i256, i8, i32 loc(#loc21) -// CHECK-NEXT: } loc(#loc18) -// CHECK-NEXT: func.func @encode_packed_82(%arg0: i24 loc({{.*}}:18:23), %arg1: i96 loc({{.*}}:18:33), %arg2: i136 loc({{.*}}:18:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: } loc(#loc17) +// CHECK-NEXT: func.func @decode_calldata_87(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:18:25)) -> (i256, i8, i32) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc23) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc23) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc23) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc24) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc25) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc25) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c96_i256 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc25) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc25) +// CHECK-NEXT: %7 = arith.addi %2, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %8 = llvm.inttoptr %7 : i256 to !llvm.ptr<2> loc(#loc25) +// CHECK-NEXT: %9 = llvm.load %8 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc25) +// CHECK-NEXT: %10 = arith.trunci %9 : i256 to i8 loc(#loc25) +// CHECK-NEXT: %11 = arith.extui %10 : i8 to i256 loc(#loc25) +// CHECK-NEXT: %12 = arith.cmpi ne, %9, %11 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: %13 = arith.addi %2, %c64_i256 : i256 loc(#loc25) +// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc25) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc25) +// CHECK-NEXT: %16 = arith.trunci %15 : i256 to i32 loc(#loc25) +// CHECK-NEXT: %17 = arith.extsi %16 : i32 to i256 loc(#loc25) +// CHECK-NEXT: %18 = arith.cmpi ne, %15, %17 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: return %6, %10, %16 : i256, i8, i32 loc(#loc26) +// CHECK-NEXT: } loc(#loc22) +// CHECK-NEXT: func.func @encode_packed_106(%arg0: i24 loc({{.*}}:22:23), %arg1: i96 loc({{.*}}:22:33), %arg2: i136 loc({{.*}}:22:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c47_i256 = arith.constant 47 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c120_i256 = arith.constant 120 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c232_i256 = arith.constant 232 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i24 : (i256) -> !llvm.ptr loc(#loc23) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i24, !llvm.ptr loc(#loc23) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i96 : (i256) -> !llvm.ptr loc(#loc24) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i96, !llvm.ptr loc(#loc24) -// CHECK-NEXT: %2 = llvm.alloca %c1_i256 x i136 : (i256) -> !llvm.ptr loc(#loc25) -// CHECK-NEXT: llvm.store %arg2, %2 {alignment = 32 : i64} : i136, !llvm.ptr loc(#loc25) -// CHECK-NEXT: %3 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i24 loc(#loc26) -// CHECK-NEXT: %4 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i96 loc(#loc27) -// CHECK-NEXT: %5 = llvm.load %2 {alignment = 32 : i64} : !llvm.ptr -> i136 loc(#loc28) -// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) -// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc29) -// CHECK-NEXT: %9 = arith.extui %3 : i24 to i256 loc(#loc29) -// CHECK-NEXT: %10 = arith.shli %9, %c232_i256 : i256 loc(#loc29) -// CHECK-NEXT: %11 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %12 = arith.addi %7, %c35_i256 : i256 loc(#loc29) -// CHECK-NEXT: %13 = arith.extui %4 : i96 to i256 loc(#loc29) -// CHECK-NEXT: %14 = arith.shli %13, %c160_i256 : i256 loc(#loc29) -// CHECK-NEXT: %15 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %16 = arith.addi %7, %c47_i256 : i256 loc(#loc29) -// CHECK-NEXT: %17 = arith.extui %5 : i136 to i256 loc(#loc29) -// CHECK-NEXT: %18 = arith.shli %17, %c120_i256 : i256 loc(#loc29) -// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %20 = arith.addi %7, %c64_i256 : i256 loc(#loc29) -// CHECK-NEXT: %21 = arith.subi %20, %8 : i256 loc(#loc29) -// CHECK-NEXT: %22 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %23 = arith.addi %7, %c64_i256 : i256 loc(#loc29) -// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: return %7 : i256 loc(#loc30) -// CHECK-NEXT: } loc(#loc22) -// CHECK-NEXT: func.func @encode_addr_95(%arg0: i256 loc({{.*}}:22:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc32) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc32) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc32) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc33) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc34) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc34) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc34) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc34) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc34) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i24 : (i256) -> !llvm.ptr loc(#loc28) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i24, !llvm.ptr loc(#loc28) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i96 : (i256) -> !llvm.ptr loc(#loc29) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i96, !llvm.ptr loc(#loc29) +// CHECK-NEXT: %2 = llvm.alloca %c1_i256 x i136 : (i256) -> !llvm.ptr loc(#loc30) +// CHECK-NEXT: llvm.store %arg2, %2 {alignment = 32 : i64} : i136, !llvm.ptr loc(#loc30) +// CHECK-NEXT: %3 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i24 loc(#loc31) +// CHECK-NEXT: %4 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i96 loc(#loc32) +// CHECK-NEXT: %5 = llvm.load %2 {alignment = 32 : i64} : !llvm.ptr -> i136 loc(#loc33) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %9 = arith.extui %3 : i24 to i256 loc(#loc34) +// CHECK-NEXT: %10 = arith.shli %9, %c232_i256 : i256 loc(#loc34) +// CHECK-NEXT: %11 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc34) // CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: return %3 : i256 loc(#loc35) -// CHECK-NEXT: } loc(#loc31) -// CHECK-NEXT: func.func @decode_addr_111(%arg0: i256 loc({{.*}}:26:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %12 = arith.addi %7, %c35_i256 : i256 loc(#loc34) +// CHECK-NEXT: %13 = arith.extui %4 : i96 to i256 loc(#loc34) +// CHECK-NEXT: %14 = arith.shli %13, %c160_i256 : i256 loc(#loc34) +// CHECK-NEXT: %15 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %16 = arith.addi %7, %c47_i256 : i256 loc(#loc34) +// CHECK-NEXT: %17 = arith.extui %5 : i136 to i256 loc(#loc34) +// CHECK-NEXT: %18 = arith.shli %17, %c120_i256 : i256 loc(#loc34) +// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %20 = arith.addi %7, %c64_i256 : i256 loc(#loc34) +// CHECK-NEXT: %21 = arith.subi %20, %8 : i256 loc(#loc34) +// CHECK-NEXT: %22 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %23 = arith.addi %7, %c64_i256 : i256 loc(#loc34) +// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %c18446744073709551615_i256 : i256 loc(#loc34) +// CHECK-NEXT: %25 = arith.cmpi ult, %23, %7 : i256 loc(#loc34) +// CHECK-NEXT: %26 = arith.ori %24, %25 : i1 loc(#loc34) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %29 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c65_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%30, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: return %7 : i256 loc(#loc35) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: func.func @encode_addr_119(%arg0: i256 loc({{.*}}:26:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc37) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc37) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc37) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc38) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc39) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc39) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc39) -// CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) -// CHECK-NEXT: } loc(#loc39) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc39) -// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc39) -// CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc39) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc39) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc39) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc39) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc39) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) // CHECK-NEXT: } loc(#loc39) -// CHECK-NEXT: return %8 : i256 loc(#loc40) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: return %3 : i256 loc(#loc40) // CHECK-NEXT: } loc(#loc36) -// CHECK-NEXT: func.func @encode_packed_addr_124(%arg0: i256 loc({{.*}}:30:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @decode_addr_135(%arg0: i256 loc({{.*}}:30:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc42) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc42) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc42) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc43) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc44) -// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc44) -// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc44) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc44) -// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc44) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %11 = arith.addi %3, %c52_i256 : i256 loc(#loc44) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: return %3 : i256 loc(#loc45) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc44) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc44) +// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc44) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc44) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: return %8 : i256 loc(#loc45) // CHECK-NEXT: } loc(#loc41) -// CHECK-NEXT: func.func @roundtrip_addr_143(%arg0: i256 loc({{.*}}:34:24)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: func.func @decode_addr_calldata_151(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:34:30)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc47) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc47) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc47) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc48) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc49) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc49) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc49) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc49) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc49) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc49) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %14 = arith.addi %3, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: %15 = arith.cmpi slt, %13, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) -// CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %18 = arith.andi %17, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc50) -// CHECK-NEXT: %19 = arith.cmpi ne, %17, %18 : i256 loc(#loc50) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) -// CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: return %18 : i256 loc(#loc51) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc47) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc47) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc48) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc49) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc49) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc49) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc49) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc49) +// CHECK-NEXT: } loc(#loc49) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc49) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc49) +// CHECK-NEXT: %7 = arith.andi %6, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc49) +// CHECK-NEXT: %8 = arith.cmpi ne, %6, %7 : i256 loc(#loc49) +// CHECK-NEXT: scf.if %8 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc49) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc49) +// CHECK-NEXT: } loc(#loc49) +// CHECK-NEXT: return %7 : i256 loc(#loc50) // CHECK-NEXT: } loc(#loc46) -// CHECK-NEXT: func.func @roundtrip_addr_tuple_169(%arg0: i256 loc({{.*}}:38:30), %arg1: i256 loc({{.*}}:38:41)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_addr_164(%arg0: i256 loc({{.*}}:38:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc53) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc53) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc54) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc54) -// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc55) -// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc56) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc57) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc57) -// CHECK-NEXT: %7 = arith.addi %5, %c96_i256 : i256 loc(#loc57) -// CHECK-NEXT: %8 = arith.andi %2, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc57) -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %10 = arith.addi %5, %c64_i256 : i256 loc(#loc57) -// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %3, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %12 = arith.subi %7, %6 : i256 loc(#loc57) -// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %14 = arith.addi %5, %c96_i256 : i256 loc(#loc57) -// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %16 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc58) -// CHECK-NEXT: %18 = arith.addi %5, %c32_i256 : i256 loc(#loc58) -// CHECK-NEXT: %19 = arith.cmpi slt, %17, %c64_i256 : i256 loc(#loc58) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc58) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc58) -// CHECK-NEXT: } loc(#loc58) -// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc58) -// CHECK-NEXT: %22 = arith.andi %21, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc58) -// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc58) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc58) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc58) -// CHECK-NEXT: } loc(#loc58) -// CHECK-NEXT: %24 = arith.addi %5, %c64_i256 : i256 loc(#loc58) -// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc58) -// CHECK-NEXT: return %22, %26 : i256, i256 loc(#loc59) -// CHECK-NEXT: } loc(#loc52) -// CHECK-NEXT: func.func @roundtrip_addr_payable_191(%arg0: i256 loc({{.*}}:42:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc52) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc52) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc52) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc53) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc54) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc54) +// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc54) +// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc54) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc54) +// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc54) +// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %11 = arith.addi %3, %c64_i256 : i256 loc(#loc54) +// CHECK-NEXT: %12 = arith.cmpi ugt, %11, %c18446744073709551615_i256 : i256 loc(#loc54) +// CHECK-NEXT: %13 = arith.cmpi ult, %11, %3 : i256 loc(#loc54) +// CHECK-NEXT: %14 = arith.ori %12, %13 : i1 loc(#loc54) +// CHECK-NEXT: scf.if %14 { +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %17 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %c65_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: "llvm.intrcall"(%18, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc54) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc54) +// CHECK-NEXT: } loc(#loc54) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %11, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: return %3 : i256 loc(#loc55) +// CHECK-NEXT: } loc(#loc51) +// CHECK-NEXT: func.func @roundtrip_addr_183(%arg0: i256 loc({{.*}}:42:24)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc61) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc61) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc61) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc62) -// CHECK-NEXT: %2 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc62) -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc63) -// CHECK-NEXT: %5 = arith.addi %4, %c32_i256 : i256 loc(#loc63) -// CHECK-NEXT: %6 = arith.addi %4, %c64_i256 : i256 loc(#loc63) -// CHECK-NEXT: %7 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %8 = arith.subi %6, %5 : i256 loc(#loc63) -// CHECK-NEXT: %9 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %10 = arith.addi %4, %c64_i256 : i256 loc(#loc63) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc64) -// CHECK-NEXT: %14 = arith.addi %4, %c32_i256 : i256 loc(#loc64) -// CHECK-NEXT: %15 = arith.cmpi slt, %13, %c32_i256 : i256 loc(#loc64) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc64) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc64) -// CHECK-NEXT: } loc(#loc64) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc64) -// CHECK-NEXT: %18 = arith.andi %17, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc64) -// CHECK-NEXT: %19 = arith.cmpi ne, %17, %18 : i256 loc(#loc64) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc64) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc64) -// CHECK-NEXT: } loc(#loc64) -// CHECK-NEXT: return %18 : i256 loc(#loc65) -// CHECK-NEXT: } loc(#loc60) -// CHECK-NEXT: func.func @encode_contract_210(%arg0: i256 loc({{.*}}:50:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc67) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc67) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc67) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc68) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc69) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc69) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc69) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc69) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc69) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc69) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: return %3 : i256 loc(#loc70) -// CHECK-NEXT: } loc(#loc66) -// CHECK-NEXT: func.func @encode_packed_contract_224(%arg0: i256 loc({{.*}}:54:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc57) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc57) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc57) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc58) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc59) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc59) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc59) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc59) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc59) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc59) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc59) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc59) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc59) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc59) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc59) +// CHECK-NEXT: } loc(#loc59) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %15 = arith.addi %3, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %18 = arith.cmpi slt, %17, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) +// CHECK-NEXT: } loc(#loc60) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc60) +// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc60) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) +// CHECK-NEXT: } loc(#loc60) +// CHECK-NEXT: return %21 : i256 loc(#loc61) +// CHECK-NEXT: } loc(#loc56) +// CHECK-NEXT: func.func @roundtrip_addr_tuple_209(%arg0: i256 loc({{.*}}:46:30), %arg1: i256 loc({{.*}}:46:41)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc72) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc72) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc72) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc73) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc74) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc74) -// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc74) -// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc74) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc74) -// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc74) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: %11 = arith.addi %3, %c52_i256 : i256 loc(#loc74) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: return %3 : i256 loc(#loc75) -// CHECK-NEXT: } loc(#loc71) -// CHECK-NEXT: func.func @decode_contract_240(%arg0: i256 loc({{.*}}:58:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc63) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc63) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc64) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc64) +// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc65) +// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc66) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc67) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc67) +// CHECK-NEXT: %7 = arith.addi %5, %c96_i256 : i256 loc(#loc67) +// CHECK-NEXT: %8 = arith.andi %2, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc67) +// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %10 = arith.addi %5, %c64_i256 : i256 loc(#loc67) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %3, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %12 = arith.subi %7, %6 : i256 loc(#loc67) +// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %14 = arith.addi %5, %c96_i256 : i256 loc(#loc67) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc67) +// CHECK-NEXT: %16 = arith.cmpi ult, %14, %5 : i256 loc(#loc67) +// CHECK-NEXT: %17 = arith.ori %15, %16 : i1 loc(#loc67) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc67) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc67) +// CHECK-NEXT: } loc(#loc67) +// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %19 = arith.addi %5, %c32_i256 : i256 loc(#loc68) +// CHECK-NEXT: %20 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc68) +// CHECK-NEXT: %22 = arith.cmpi slt, %21, %c64_i256 : i256 loc(#loc68) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc68) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc68) +// CHECK-NEXT: } loc(#loc68) +// CHECK-NEXT: %23 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc68) +// CHECK-NEXT: %25 = arith.andi %24, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc68) +// CHECK-NEXT: %26 = arith.cmpi ne, %24, %25 : i256 loc(#loc68) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc68) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc68) +// CHECK-NEXT: } loc(#loc68) +// CHECK-NEXT: %27 = arith.addi %5, %c64_i256 : i256 loc(#loc68) +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc68) +// CHECK-NEXT: return %25, %29 : i256, i256 loc(#loc69) +// CHECK-NEXT: } loc(#loc62) +// CHECK-NEXT: func.func @roundtrip_addr_payable_231(%arg0: i256 loc({{.*}}:50:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc71) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc71) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc71) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc72) +// CHECK-NEXT: %2 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc72) +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc73) +// CHECK-NEXT: %5 = arith.addi %4, %c32_i256 : i256 loc(#loc73) +// CHECK-NEXT: %6 = arith.addi %4, %c64_i256 : i256 loc(#loc73) +// CHECK-NEXT: %7 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %8 = arith.subi %6, %5 : i256 loc(#loc73) +// CHECK-NEXT: %9 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %10 = arith.addi %4, %c64_i256 : i256 loc(#loc73) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc73) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %4 : i256 loc(#loc73) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc73) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc73) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc73) +// CHECK-NEXT: } loc(#loc73) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %15 = arith.addi %4, %c32_i256 : i256 loc(#loc74) +// CHECK-NEXT: %16 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc74) +// CHECK-NEXT: %18 = arith.cmpi slt, %17, %c32_i256 : i256 loc(#loc74) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc74) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc74) +// CHECK-NEXT: } loc(#loc74) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc74) +// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc74) +// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc74) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc74) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc74) +// CHECK-NEXT: } loc(#loc74) +// CHECK-NEXT: return %21 : i256 loc(#loc75) +// CHECK-NEXT: } loc(#loc70) +// CHECK-NEXT: func.func @encode_contract_250(%arg0: i256 loc({{.*}}:58:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc77) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc77) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc77) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc78) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc79) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc79) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc79) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc79) -// CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc79) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc79) -// CHECK-NEXT: } loc(#loc79) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc79) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc79) -// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc79) -// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc79) -// CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc79) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc79) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc79) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc79) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc79) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc79) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc79) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc79) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc79) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc79) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc79) // CHECK-NEXT: } loc(#loc79) -// CHECK-NEXT: return %8 : i256 loc(#loc80) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: return %3 : i256 loc(#loc80) // CHECK-NEXT: } loc(#loc76) -// CHECK-NEXT: func.func @roundtrip_contract_260(%arg0: i256 loc({{.*}}:62:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_contract_264(%arg0: i256 loc({{.*}}:62:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -725,221 +935,217 @@ contract StorageBytes { // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc84) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc84) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc84) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc84) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc84) +// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc84) +// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc84) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc84) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc84) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc84) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc85) -// CHECK-NEXT: %14 = arith.addi %3, %c32_i256 : i256 loc(#loc85) -// CHECK-NEXT: %15 = arith.cmpi slt, %13, %c32_i256 : i256 loc(#loc85) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc85) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc85) -// CHECK-NEXT: } loc(#loc85) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc85) -// CHECK-NEXT: %18 = arith.andi %17, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc85) -// CHECK-NEXT: %19 = arith.cmpi ne, %17, %18 : i256 loc(#loc85) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc85) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc85) -// CHECK-NEXT: } loc(#loc85) -// CHECK-NEXT: return %18 : i256 loc(#loc86) +// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc84) +// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc84) +// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: %11 = arith.addi %3, %c64_i256 : i256 loc(#loc84) +// CHECK-NEXT: %12 = arith.cmpi ugt, %11, %c18446744073709551615_i256 : i256 loc(#loc84) +// CHECK-NEXT: %13 = arith.cmpi ult, %11, %3 : i256 loc(#loc84) +// CHECK-NEXT: %14 = arith.ori %12, %13 : i1 loc(#loc84) +// CHECK-NEXT: scf.if %14 { +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: %17 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %c65_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: "llvm.intrcall"(%18, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc84) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc84) +// CHECK-NEXT: } loc(#loc84) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %11, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: return %3 : i256 loc(#loc85) // CHECK-NEXT: } loc(#loc81) -// CHECK-NEXT: func.func @decode_contract_tuple_280(%arg0: i256 loc({{.*}}:66:31)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @decode_contract_280(%arg0: i256 loc({{.*}}:66:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc88) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc88) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc88) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc89) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc90) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc90) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c64_i256 : i256 loc(#loc90) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc87) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc87) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc87) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc88) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc89) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc89) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc89) // CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc90) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc90) -// CHECK-NEXT: } loc(#loc90) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc90) -// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc90) -// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc90) +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc89) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc89) +// CHECK-NEXT: } loc(#loc89) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc89) +// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc89) +// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc89) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc90) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc90) -// CHECK-NEXT: } loc(#loc90) -// CHECK-NEXT: %10 = arith.addi %1, %c64_i256 : i256 loc(#loc90) -// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc90) -// CHECK-NEXT: return %8, %12 : i256, i256 loc(#loc91) -// CHECK-NEXT: } loc(#loc87) -// CHECK-NEXT: func.func @encode_packed_array_signed_298(%arg0: i256 loc({{.*}}:72:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc93) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc93) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc93) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc94) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc95) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc95) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc95) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc95) -// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc95) -// CHECK-NEXT: %16 = arith.extsi %15 : i8 to i256 loc(#loc95) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc95) -// CHECK-NEXT: } loc(#loc95) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc95) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: return %3 : i256 loc(#loc96) -// CHECK-NEXT: } loc(#loc92) -// CHECK-NEXT: func.func @encode_packed_array_unsigned_312(%arg0: i256 loc({{.*}}:76:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc89) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc89) +// CHECK-NEXT: } loc(#loc89) +// CHECK-NEXT: return %8 : i256 loc(#loc90) +// CHECK-NEXT: } loc(#loc86) +// CHECK-NEXT: func.func @decode_contract_calldata_296(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:70:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc98) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc98) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc98) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc99) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc100) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) -// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc100) -// CHECK-NEXT: %16 = arith.extui %15 : i8 to i256 loc(#loc100) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc100) -// CHECK-NEXT: } loc(#loc100) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc100) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: return %3 : i256 loc(#loc101) -// CHECK-NEXT: } loc(#loc97) -// CHECK-NEXT: func.func @encode_packed_array_enum_327(%arg0: i256 loc({{.*}}:80:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc92) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc92) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc92) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc93) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc94) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc94) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc94) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc94) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc94) +// CHECK-NEXT: } loc(#loc94) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc94) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc94) +// CHECK-NEXT: %7 = arith.andi %6, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc94) +// CHECK-NEXT: %8 = arith.cmpi ne, %6, %7 : i256 loc(#loc94) +// CHECK-NEXT: scf.if %8 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc94) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc94) +// CHECK-NEXT: } loc(#loc94) +// CHECK-NEXT: return %7 : i256 loc(#loc95) +// CHECK-NEXT: } loc(#loc91) +// CHECK-NEXT: func.func @roundtrip_contract_316(%arg0: i256 loc({{.*}}:74:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc97) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc97) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc97) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc98) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc99) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc99) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc99) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc99) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc99) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc99) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc99) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc99) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc99) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc99) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc99) +// CHECK-NEXT: } loc(#loc99) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %15 = arith.addi %3, %c32_i256 : i256 loc(#loc100) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) +// CHECK-NEXT: %18 = arith.cmpi slt, %17, %c32_i256 : i256 loc(#loc100) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc100) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc100) +// CHECK-NEXT: } loc(#loc100) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) +// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc100) +// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc100) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc100) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc100) +// CHECK-NEXT: } loc(#loc100) +// CHECK-NEXT: return %21 : i256 loc(#loc101) +// CHECK-NEXT: } loc(#loc96) +// CHECK-NEXT: func.func @decode_contract_tuple_336(%arg0: i256 loc({{.*}}:78:31)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc103) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc103) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc103) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc104) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc105) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) -// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c2_i256 : i256 loc(#loc105) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %c33_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc105) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc105) -// CHECK-NEXT: } loc(#loc105) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc105) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc105) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c64_i256 : i256 loc(#loc105) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc105) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc105) +// CHECK-NEXT: } loc(#loc105) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) +// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc105) +// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc105) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc105) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc105) // CHECK-NEXT: } loc(#loc105) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc105) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: return %3 : i256 loc(#loc106) +// CHECK-NEXT: %10 = arith.addi %1, %c64_i256 : i256 loc(#loc105) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) +// CHECK-NEXT: return %8, %12 : i256, i256 loc(#loc106) // CHECK-NEXT: } loc(#loc102) -// CHECK-NEXT: func.func @encode_packed_array_bool_341(%arg0: i256 loc({{.*}}:84:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: func.func @decode_contract_tuple_calldata_356(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:82:40)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc108) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc108) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc108) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc109) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc110) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc110) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc110) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc110) -// CHECK-NEXT: %15 = arith.cmpi ne, %14, %c0_i256 : i256 loc(#loc110) -// CHECK-NEXT: %16 = arith.extui %15 : i1 to i256 loc(#loc110) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc110) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc108) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc108) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc109) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc110) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc110) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c64_i256 : i256 loc(#loc110) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc110) +// CHECK-NEXT: "llvm.intrcall"(%12, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc110) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc110) +// CHECK-NEXT: } loc(#loc110) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc110) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc110) +// CHECK-NEXT: %7 = arith.andi %6, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc110) +// CHECK-NEXT: %8 = arith.cmpi ne, %6, %7 : i256 loc(#loc110) +// CHECK-NEXT: scf.if %8 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc110) +// CHECK-NEXT: "llvm.intrcall"(%12, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc110) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc110) // CHECK-NEXT: } loc(#loc110) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc110) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: return %3 : i256 loc(#loc111) +// CHECK-NEXT: %9 = arith.addi %2, %c32_i256 : i256 loc(#loc110) +// CHECK-NEXT: %10 = llvm.inttoptr %9 : i256 to !llvm.ptr<2> loc(#loc110) +// CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc110) +// CHECK-NEXT: return %7, %11 : i256, i256 loc(#loc111) // CHECK-NEXT: } loc(#loc107) -// CHECK-NEXT: func.func @encode_packed_array_address_355(%arg0: i256 loc({{.*}}:88:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_array_signed_374(%arg0: i256 loc({{.*}}:88:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -955,25 +1161,50 @@ contract StorageBytes { // CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc115) // CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc115) // CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc115) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc115) -// CHECK-NEXT: %15 = arith.andi %14, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc115) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc115) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc115) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc115) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc115) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc115) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc115) +// CHECK-NEXT: %23 = arith.trunci %22 : i256 to i8 loc(#loc115) +// CHECK-NEXT: %24 = arith.extsi %23 : i8 to i256 loc(#loc115) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc115) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc115) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc115) +// CHECK-NEXT: } loc(#loc115) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc115) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc115) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc115) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc115) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc115) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc115) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc115) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc115) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc115) // CHECK-NEXT: } loc(#loc115) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc115) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) // CHECK-NEXT: return %3 : i256 loc(#loc116) // CHECK-NEXT: } loc(#loc112) -// CHECK-NEXT: func.func @encode_packed_contract_address_370(%arg0: i256 loc({{.*}}:92:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_array_unsigned_388(%arg0: i256 loc({{.*}}:92:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -989,185 +1220,296 @@ contract StorageBytes { // CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc120) // CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc120) // CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc120) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc120) -// CHECK-NEXT: %15 = arith.andi %14, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc120) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc120) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc120) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc120) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc120) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc120) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc120) +// CHECK-NEXT: %23 = arith.trunci %22 : i256 to i8 loc(#loc120) +// CHECK-NEXT: %24 = arith.extui %23 : i8 to i256 loc(#loc120) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc120) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc120) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc120) +// CHECK-NEXT: } loc(#loc120) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc120) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc120) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc120) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc120) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc120) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc120) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc120) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc120) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc120) // CHECK-NEXT: } loc(#loc120) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc120) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) // CHECK-NEXT: return %3 : i256 loc(#loc121) // CHECK-NEXT: } loc(#loc117) -// CHECK-NEXT: func.func @encode_packed_calldata_array_signed_384(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:96:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_array_enum_403(%arg0: i256 loc({{.*}}:96:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc123) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc123) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc123) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc124) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc123) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc123) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc124) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc125) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc125) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc125) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc125) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc125) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc125) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc125) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc125) -// CHECK-NEXT: %14 = arith.trunci %13 : i256 to i8 loc(#loc125) -// CHECK-NEXT: %15 = arith.extsi %14 : i8 to i256 loc(#loc125) -// CHECK-NEXT: %16 = arith.cmpi ne, %13, %15 : i256 loc(#loc125) -// CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc125) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc125) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc125) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc125) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc125) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c2_i256 : i256 loc(#loc125) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c33_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc125) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc125) // CHECK-NEXT: } loc(#loc125) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: llvm.store %15, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc125) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc125) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc125) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc125) +// CHECK-NEXT: } loc(#loc125) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc125) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc125) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc125) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc125) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc125) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc125) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc125) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc125) // CHECK-NEXT: } loc(#loc125) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc125) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) // CHECK-NEXT: return %3 : i256 loc(#loc126) // CHECK-NEXT: } loc(#loc122) -// CHECK-NEXT: func.func @encode_packed_calldata_array_unsigned_398(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:100:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_array_bool_417(%arg0: i256 loc({{.*}}:100:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc128) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc128) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc128) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc129) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc128) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc128) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc129) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc130) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc130) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc130) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc130) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc130) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc130) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc130) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc130) -// CHECK-NEXT: %14 = arith.trunci %13 : i256 to i8 loc(#loc130) -// CHECK-NEXT: %15 = arith.extui %14 : i8 to i256 loc(#loc130) -// CHECK-NEXT: %16 = arith.cmpi ne, %13, %15 : i256 loc(#loc130) -// CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc130) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc130) -// CHECK-NEXT: } loc(#loc130) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: llvm.store %15, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc130) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc130) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc130) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc130) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc130) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc130) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc130) +// CHECK-NEXT: %23 = arith.cmpi ne, %22, %c0_i256 : i256 loc(#loc130) +// CHECK-NEXT: %24 = arith.extui %23 : i1 to i256 loc(#loc130) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc130) +// CHECK-NEXT: } loc(#loc130) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc130) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc130) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc130) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc130) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc130) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc130) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc130) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc130) // CHECK-NEXT: } loc(#loc130) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc130) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) // CHECK-NEXT: return %3 : i256 loc(#loc131) // CHECK-NEXT: } loc(#loc127) -// CHECK-NEXT: func.func @encode_packed_calldata_array_enum_413(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:104:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_array_address_431(%arg0: i256 loc({{.*}}:104:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc133) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc133) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc133) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc134) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc133) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc133) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc134) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc135) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc135) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc135) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc135) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc135) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc135) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc135) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc135) -// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c2_i256 : i256 loc(#loc135) -// CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: "llvm.intrcall"(%18, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc135) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc135) -// CHECK-NEXT: } loc(#loc135) -// CHECK-NEXT: %15 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: llvm.store %13, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: %16 = arith.addi %arg2, %c32_i256 : i256 loc(#loc135) -// CHECK-NEXT: %17 = arith.addi %arg3, %c32_i256 : i256 loc(#loc135) -// CHECK-NEXT: scf.yield %16, %17 : i256, i256 loc(#loc135) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc135) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc135) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc135) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc135) +// CHECK-NEXT: %23 = arith.andi %22, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc135) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc135) +// CHECK-NEXT: } loc(#loc135) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc135) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc135) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc135) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc135) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc135) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc135) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc135) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc135) // CHECK-NEXT: } loc(#loc135) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc135) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) // CHECK-NEXT: return %3 : i256 loc(#loc136) // CHECK-NEXT: } loc(#loc132) -// CHECK-NEXT: func.func @encode_packed_calldata_array_bool_427(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:108:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_contract_address_446(%arg0: i256 loc({{.*}}:108:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc138) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc138) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc138) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc139) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc138) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc138) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc139) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc140) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc140) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc140) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc140) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc140) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc140) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc140) -// CHECK-NEXT: %14 = arith.cmpi ne, %13, %c0_i256 : i256 loc(#loc140) -// CHECK-NEXT: %15 = arith.extui %14 : i1 to i256 loc(#loc140) -// CHECK-NEXT: %16 = arith.cmpi ne, %13, %15 : i256 loc(#loc140) -// CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc140) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc140) -// CHECK-NEXT: } loc(#loc140) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: llvm.store %15, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc140) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc140) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc140) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc140) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc140) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc140) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc140) +// CHECK-NEXT: %23 = arith.andi %22, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc140) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc140) +// CHECK-NEXT: } loc(#loc140) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc140) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc140) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc140) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc140) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc140) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc140) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc140) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc140) // CHECK-NEXT: } loc(#loc140) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc140) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) // CHECK-NEXT: return %3 : i256 loc(#loc141) // CHECK-NEXT: } loc(#loc137) -// CHECK-NEXT: func.func @encode_packed_calldata_array_address_441(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:112:46)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_signed_460(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:112:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1182,32 +1524,56 @@ contract StorageBytes { // CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc145) // CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc145) // CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc145) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc145) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc145) -// CHECK-NEXT: %14 = arith.andi %13, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc145) -// CHECK-NEXT: %15 = arith.cmpi ne, %13, %14 : i256 loc(#loc145) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc145) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc145) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc145) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc145) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc145) +// CHECK-NEXT: %22 = arith.trunci %21 : i256 to i8 loc(#loc145) +// CHECK-NEXT: %23 = arith.extsi %22 : i8 to i256 loc(#loc145) +// CHECK-NEXT: %24 = arith.cmpi ne, %21, %23 : i256 loc(#loc145) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc145) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc145) // CHECK-NEXT: } loc(#loc145) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc145) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc145) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc145) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %23, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc145) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc145) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc145) +// CHECK-NEXT: } loc(#loc145) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc145) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc145) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc145) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc145) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc145) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc145) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc145) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc145) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc145) // CHECK-NEXT: } loc(#loc145) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc145) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) // CHECK-NEXT: return %3 : i256 loc(#loc146) // CHECK-NEXT: } loc(#loc142) -// CHECK-NEXT: func.func @encode_packed_calldata_array_contract_456(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:116:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_unsigned_474(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:116:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1222,356 +1588,484 @@ contract StorageBytes { // CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc150) // CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc150) // CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc150) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc150) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc150) -// CHECK-NEXT: %14 = arith.andi %13, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc150) -// CHECK-NEXT: %15 = arith.cmpi ne, %13, %14 : i256 loc(#loc150) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc150) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc150) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc150) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc150) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc150) +// CHECK-NEXT: %22 = arith.trunci %21 : i256 to i8 loc(#loc150) +// CHECK-NEXT: %23 = arith.extui %22 : i8 to i256 loc(#loc150) +// CHECK-NEXT: %24 = arith.cmpi ne, %21, %23 : i256 loc(#loc150) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc150) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc150) // CHECK-NEXT: } loc(#loc150) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc150) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc150) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc150) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %23, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc150) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc150) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc150) // CHECK-NEXT: } loc(#loc150) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc150) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc150) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc150) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc150) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc150) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc150) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc150) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc150) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc150) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc150) +// CHECK-NEXT: } loc(#loc150) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) // CHECK-NEXT: return %3 : i256 loc(#loc151) // CHECK-NEXT: } loc(#loc147) -// CHECK-NEXT: func.func @encode_bool_469(%arg0: i1 loc({{.*}}:120:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_enum_489(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:120:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc153) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc153) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc153) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc154) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc153) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc153) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc154) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc155) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc155) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc155) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc155) -// CHECK-NEXT: %6 = arith.extui %1 : i1 to i256 loc(#loc155) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc155) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc155) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc155) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc155) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc155) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc155) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc155) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc155) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc155) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c2_i256 : i256 loc(#loc155) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc155) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc155) +// CHECK-NEXT: } loc(#loc155) +// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc155) +// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc155) +// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc155) +// CHECK-NEXT: } loc(#loc155) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc155) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc155) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc155) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc155) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc155) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc155) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc155) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc155) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc155) +// CHECK-NEXT: } loc(#loc155) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) // CHECK-NEXT: return %3 : i256 loc(#loc156) // CHECK-NEXT: } loc(#loc152) -// CHECK-NEXT: func.func @encode_uint8_482(%arg0: i8 loc({{.*}}:124:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_bool_503(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:124:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc158) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i8 : (i256) -> !llvm.ptr loc(#loc158) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i8, !llvm.ptr loc(#loc158) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i8 loc(#loc159) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc158) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc158) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc159) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc160) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc160) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc160) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc160) -// CHECK-NEXT: %6 = arith.extui %1 : i8 to i256 loc(#loc160) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc160) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc160) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc160) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc160) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc160) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc160) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc160) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc160) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc160) +// CHECK-NEXT: %22 = arith.cmpi ne, %21, %c0_i256 : i256 loc(#loc160) +// CHECK-NEXT: %23 = arith.extui %22 : i1 to i256 loc(#loc160) +// CHECK-NEXT: %24 = arith.cmpi ne, %21, %23 : i256 loc(#loc160) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc160) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc160) +// CHECK-NEXT: } loc(#loc160) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %23, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc160) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc160) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc160) +// CHECK-NEXT: } loc(#loc160) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc160) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc160) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc160) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc160) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc160) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc160) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc160) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc160) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc160) +// CHECK-NEXT: } loc(#loc160) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) // CHECK-NEXT: return %3 : i256 loc(#loc161) // CHECK-NEXT: } loc(#loc157) -// CHECK-NEXT: func.func @encode_enum_496(%arg0: i256 loc({{.*}}:128:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_address_517(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:128:46)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc163) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc163) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc163) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc164) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc163) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc163) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc164) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc165) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc165) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc165) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc165) -// CHECK-NEXT: %6 = arith.cmpi ugt, %1, %c2_i256 : i256 loc(#loc165) -// CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %c33_i256, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: "llvm.intrcall"(%14, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc165) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc165) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc165) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc165) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc165) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc165) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc165) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc165) +// CHECK-NEXT: %22 = arith.andi %21, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc165) +// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc165) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc165) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc165) +// CHECK-NEXT: } loc(#loc165) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc165) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc165) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc165) +// CHECK-NEXT: } loc(#loc165) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc165) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc165) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc165) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc165) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc165) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc165) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc165) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc165) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc165) // CHECK-NEXT: } loc(#loc165) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %1, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc165) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc165) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) // CHECK-NEXT: return %3 : i256 loc(#loc166) // CHECK-NEXT: } loc(#loc162) -// CHECK-NEXT: func.func @encode_bytes5_509(%arg0: i256 loc({{.*}}:132:23)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_calldata_array_contract_532(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:132:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc168) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc168) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc168) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc169) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc168) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc168) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc169) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc170) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc170) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc170) -// CHECK-NEXT: %6 = arith.andi %1, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc170) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc170) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc170) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc170) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc170) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc170) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc170) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc170) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc170) +// CHECK-NEXT: %22 = arith.andi %21, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc170) +// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc170) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc170) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc170) +// CHECK-NEXT: } loc(#loc170) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc170) +// CHECK-NEXT: } loc(#loc170) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc170) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc170) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc170) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc170) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc170) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc170) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc170) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc170) +// CHECK-NEXT: } loc(#loc170) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) // CHECK-NEXT: return %3 : i256 loc(#loc171) // CHECK-NEXT: } loc(#loc167) -// CHECK-NEXT: func.func @encode_array_calldata_unsigned_523(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:136:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_bool_545(%arg0: i1 loc({{.*}}:136:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc173) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc173) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc173) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc174) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc173) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc173) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc174) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc175) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc175) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc175) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc175) +// CHECK-NEXT: %6 = arith.extui %1 : i1 to i256 loc(#loc175) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc175) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc175) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc175) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc175) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc175) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc175) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc175) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc175) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc175) -// CHECK-NEXT: %21 = arith.trunci %20 : i256 to i8 loc(#loc175) -// CHECK-NEXT: %22 = arith.extui %21 : i8 to i256 loc(#loc175) -// CHECK-NEXT: %23 = arith.cmpi ne, %20, %22 : i256 loc(#loc175) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc175) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc175) -// CHECK-NEXT: } loc(#loc175) -// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc175) -// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc175) -// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc175) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc175) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc175) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc175) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc175) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc175) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc175) // CHECK-NEXT: } loc(#loc175) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc175) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: return %3 : i256 loc(#loc176) // CHECK-NEXT: } loc(#loc172) -// CHECK-NEXT: func.func @encode_array_calldata_nested_unsigned_538(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:140:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_uint8_558(%arg0: i8 loc({{.*}}:140:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc178) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc178) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc178) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc179) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i8 : (i256) -> !llvm.ptr loc(#loc178) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i8, !llvm.ptr loc(#loc178) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i8 loc(#loc179) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc180) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc180) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc180) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc180) +// CHECK-NEXT: %6 = arith.extui %1 : i8 to i256 loc(#loc180) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc180) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc180) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc180) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc180) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc180) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc180) -// CHECK-NEXT: %15:3 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12, %arg4 = %14) -> (i256, i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc180) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc180) -// CHECK-NEXT: %21 = arith.addi %12, %20 : i256 loc(#loc180) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<2> loc(#loc180) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc180) -// CHECK-NEXT: %24 = arith.addi %21, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %25 = arith.subi %arg4, %11 : i256 loc(#loc180) -// CHECK-NEXT: %26 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %27 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %28 = arith.index_castui %23 : i256 to index loc(#loc180) -// CHECK-NEXT: %29 = arith.addi %arg4, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %30 = arith.muli %23, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %31 = arith.addi %29, %30 : i256 loc(#loc180) -// CHECK-NEXT: %32:2 = scf.for %arg5 = %c0 to %28 step %c1 iter_args(%arg6 = %29, %arg7 = %24) -> (i256, i256) { -// CHECK-NEXT: %35 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<2> loc(#loc180) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc180) -// CHECK-NEXT: %37 = arith.trunci %36 : i256 to i8 loc(#loc180) -// CHECK-NEXT: %38 = arith.extui %37 : i8 to i256 loc(#loc180) -// CHECK-NEXT: %39 = arith.cmpi ne, %36, %38 : i256 loc(#loc180) -// CHECK-NEXT: scf.if %39 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc180) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc180) -// CHECK-NEXT: } loc(#loc180) -// CHECK-NEXT: %40 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %38, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %41 = arith.addi %arg6, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %42 = arith.addi %arg7, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: scf.yield %41, %42 : i256, i256 loc(#loc180) -// CHECK-NEXT: } loc(#loc180) -// CHECK-NEXT: %33 = arith.addi %arg2, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %34 = arith.addi %arg3, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: scf.yield %33, %34, %31 : i256, i256, i256 loc(#loc180) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc180) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc180) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc180) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc180) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc180) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc180) // CHECK-NEXT: } loc(#loc180) -// CHECK-NEXT: %16 = arith.subi %15#2, %4 : i256 loc(#loc180) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %15#2, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: return %3 : i256 loc(#loc181) // CHECK-NEXT: } loc(#loc177) -// CHECK-NEXT: func.func @encode_array_calldata_bool_552(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:144:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_enum_572(%arg0: i256 loc({{.*}}:144:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc183) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc183) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc183) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc184) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc183) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc183) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc184) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc185) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc185) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc185) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc185) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc185) +// CHECK-NEXT: %6 = arith.cmpi ugt, %1, %c2_i256 : i256 loc(#loc185) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c33_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc185) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc185) +// CHECK-NEXT: } loc(#loc185) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc185) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %1, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc185) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc185) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc185) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc185) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc185) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc185) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc185) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc185) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc185) -// CHECK-NEXT: %21 = arith.cmpi ne, %20, %c0_i256 : i256 loc(#loc185) -// CHECK-NEXT: %22 = arith.extui %21 : i1 to i256 loc(#loc185) -// CHECK-NEXT: %23 = arith.cmpi ne, %20, %22 : i256 loc(#loc185) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc185) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc185) -// CHECK-NEXT: } loc(#loc185) -// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc185) -// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc185) -// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc185) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc185) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc185) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc185) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc185) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc185) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc185) // CHECK-NEXT: } loc(#loc185) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc185) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) // CHECK-NEXT: return %3 : i256 loc(#loc186) // CHECK-NEXT: } loc(#loc182) -// CHECK-NEXT: func.func @encode_array_calldata_enum_567(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:148:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_bytes5_585(%arg0: i256 loc({{.*}}:148:23)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc188) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc188) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc188) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc189) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc188) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc188) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc189) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc190) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc190) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc190) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc190) +// CHECK-NEXT: %6 = arith.andi %1, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc190) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc190) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc190) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc190) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc190) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc190) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc190) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc190) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc190) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc190) -// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c2_i256 : i256 loc(#loc190) -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: "llvm.intrcall"(%25, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc190) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc190) -// CHECK-NEXT: } loc(#loc190) -// CHECK-NEXT: %22 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: llvm.store %20, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %23 = arith.addi %arg2, %c32_i256 : i256 loc(#loc190) -// CHECK-NEXT: %24 = arith.addi %arg3, %c32_i256 : i256 loc(#loc190) -// CHECK-NEXT: scf.yield %23, %24 : i256, i256 loc(#loc190) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc190) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc190) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc190) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc190) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc190) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc190) // CHECK-NEXT: } loc(#loc190) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc190) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: return %3 : i256 loc(#loc191) // CHECK-NEXT: } loc(#loc187) -// CHECK-NEXT: func.func @encode_array_calldata_address_581(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:152:39)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_unsigned_599(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:152:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1596,32 +2090,62 @@ contract StorageBytes { // CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc195) // CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc195) // CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc195) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc195) -// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc195) -// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc195) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc195) +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc195) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc195) +// CHECK-NEXT: %28 = arith.trunci %27 : i256 to i8 loc(#loc195) +// CHECK-NEXT: %29 = arith.extui %28 : i8 to i256 loc(#loc195) +// CHECK-NEXT: %30 = arith.cmpi ne, %27, %29 : i256 loc(#loc195) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc195) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc195) // CHECK-NEXT: } loc(#loc195) -// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc195) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc195) -// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc195) +// CHECK-NEXT: %31 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %29, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %32 = arith.addi %arg2, %c32_i256 : i256 loc(#loc195) +// CHECK-NEXT: %33 = arith.addi %arg3, %c32_i256 : i256 loc(#loc195) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc195) // CHECK-NEXT: } loc(#loc195) // CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc195) // CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc195) // CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc195) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc195) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc195) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc195) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc195) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc195) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc195) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc195) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc195) +// CHECK-NEXT: } loc(#loc195) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) // CHECK-NEXT: return %3 : i256 loc(#loc196) // CHECK-NEXT: } loc(#loc192) -// CHECK-NEXT: func.func @encode_array_calldata_contract_596(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:156:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_nested_unsigned_614(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:156:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099523263123094306816 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099014633433810337792 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099231078946096545792 : i256 loc(#loc) +// CHECK-NEXT: %c30_i256 = arith.constant 30 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1645,73 +2169,188 @@ contract StorageBytes { // CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc200) // CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc200) // CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc200) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc200) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) -// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc200) -// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc200) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: %15:3 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12, %arg4 = %14) -> (i256, i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc200) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) +// CHECK-NEXT: %28 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc200) +// CHECK-NEXT: %29 = arith.subi %28, %12 : i256 loc(#loc200) +// CHECK-NEXT: %30 = arith.subi %29, %c31_i256 : i256 loc(#loc200) +// CHECK-NEXT: %31 = arith.cmpi sge, %27, %30 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %31 { +// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc200) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc200) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c30_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc200) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %60 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%60, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %32 = arith.addi %12, %27 : i256 loc(#loc200) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<2> loc(#loc200) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) +// CHECK-NEXT: %35 = arith.addi %32, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %36 = arith.cmpi ugt, %34, %c18446744073709551615_i256 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc200) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc200) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c30_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc200) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %60 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%60, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) // CHECK-NEXT: } loc(#loc200) -// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc200) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc200) -// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc200) +// CHECK-NEXT: %37 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc200) +// CHECK-NEXT: %38 = arith.muli %34, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %39 = arith.subi %37, %38 : i256 loc(#loc200) +// CHECK-NEXT: %40 = arith.cmpi sgt, %35, %39 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %40 { +// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc200) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc200) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c30_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc200) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %60 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%60, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %41 = arith.subi %arg4, %11 : i256 loc(#loc200) +// CHECK-NEXT: %42 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %41, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %43 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %34, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %44 = arith.index_castui %34 : i256 to index loc(#loc200) +// CHECK-NEXT: %45 = arith.addi %arg4, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %46 = arith.muli %34, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %47 = arith.addi %45, %46 : i256 loc(#loc200) +// CHECK-NEXT: %48:2 = scf.for %arg5 = %c0 to %44 step %c1 iter_args(%arg6 = %45, %arg7 = %35) -> (i256, i256) { +// CHECK-NEXT: %51 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<2> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = arith.trunci %52 : i256 to i8 loc(#loc200) +// CHECK-NEXT: %54 = arith.extui %53 : i8 to i256 loc(#loc200) +// CHECK-NEXT: %55 = arith.cmpi ne, %52, %54 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %59 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%59, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %56 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %54, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %57 = arith.addi %arg6, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %arg7, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: scf.yield %57, %58 : i256, i256 loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %49 = arith.addi %arg2, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %50 = arith.addi %arg3, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: scf.yield %49, %50, %47 : i256, i256, i256 loc(#loc200) // CHECK-NEXT: } loc(#loc200) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc200) +// CHECK-NEXT: %16 = arith.subi %15#2, %4 : i256 loc(#loc200) // CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc200) // CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %18 = arith.subi %15#2, %3 : i256 loc(#loc200) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc200) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc200) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc200) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc200) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc200) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) // CHECK-NEXT: return %3 : i256 loc(#loc201) // CHECK-NEXT: } loc(#loc197) -// CHECK-NEXT: func.func @encode_packed_calldata_array_bytes5_610(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:160:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @enc_nested_631(%arg0: i256 loc({{.*}}:160:20)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc203) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc203) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc203) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc204) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc203) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc203) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc204) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc205) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc205) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc205) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc205) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc205) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc205) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc205) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc205) -// CHECK-NEXT: %14 = arith.andi %13, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc205) -// CHECK-NEXT: %15 = arith.cmpi ne, %13, %14 : i256 loc(#loc205) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc205) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc205) -// CHECK-NEXT: } loc(#loc205) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc205) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc205) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc205) +// CHECK-NEXT: %5 = arith.addi %3, %c224_i256 : i256 loc(#loc205) +// CHECK-NEXT: %6:2 = scf.for %arg1 = %c0 to %c3 step %c1 iter_args(%arg2 = %4, %arg3 = %1) -> (i256, i256) { +// CHECK-NEXT: %14 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %15 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc205) +// CHECK-NEXT: "llvm.intr.memcpy"(%14, %15, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc205) +// CHECK-NEXT: %16 = arith.addi %arg2, %c64_i256 : i256 loc(#loc205) +// CHECK-NEXT: %17 = arith.addi %arg3, %c64_i256 : i256 loc(#loc205) +// CHECK-NEXT: scf.yield %16, %17 : i256, i256 loc(#loc205) +// CHECK-NEXT: } loc(#loc205) +// CHECK-NEXT: %7 = arith.subi %5, %4 : i256 loc(#loc205) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %9 = arith.addi %3, %c224_i256 : i256 loc(#loc205) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc205) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %3 : i256 loc(#loc205) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc205) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc205) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc205) // CHECK-NEXT: } loc(#loc205) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc205) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) // CHECK-NEXT: return %3 : i256 loc(#loc206) // CHECK-NEXT: } loc(#loc202) -// CHECK-NEXT: func.func @encode_array_calldata_bytes5_624(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:164:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_bool_645(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:164:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -1736,142 +2375,593 @@ contract StorageBytes { // CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc210) // CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc210) // CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc210) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc210) -// CHECK-NEXT: %21 = arith.andi %20, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc210) -// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc210) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc210) +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc210) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc210) +// CHECK-NEXT: %28 = arith.cmpi ne, %27, %c0_i256 : i256 loc(#loc210) +// CHECK-NEXT: %29 = arith.extui %28 : i1 to i256 loc(#loc210) +// CHECK-NEXT: %30 = arith.cmpi ne, %27, %29 : i256 loc(#loc210) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc210) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc210) // CHECK-NEXT: } loc(#loc210) -// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc210) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc210) -// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc210) +// CHECK-NEXT: %31 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %29, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %32 = arith.addi %arg2, %c32_i256 : i256 loc(#loc210) +// CHECK-NEXT: %33 = arith.addi %arg3, %c32_i256 : i256 loc(#loc210) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc210) // CHECK-NEXT: } loc(#loc210) // CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc210) // CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc210) // CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc210) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc210) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc210) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc210) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc210) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc210) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc210) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc210) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc210) +// CHECK-NEXT: } loc(#loc210) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) // CHECK-NEXT: return %3 : i256 loc(#loc211) // CHECK-NEXT: } loc(#loc207) -// CHECK-NEXT: func.func @encode_selector_640(%arg0: i256 loc({{.*}}:168:25), %arg1: i256 loc({{.*}}:168:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_enum_660(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:168:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc213) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc213) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc213) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc214) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc215) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc215) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc215) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc215) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc215) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc215) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc215) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc215) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc215) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc215) +// CHECK-NEXT: %28 = arith.cmpi ugt, %27, %c2_i256 : i256 loc(#loc215) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc215) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc215) +// CHECK-NEXT: } loc(#loc215) +// CHECK-NEXT: %29 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %27, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %30 = arith.addi %arg2, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %31 = arith.addi %arg3, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: scf.yield %30, %31 : i256, i256 loc(#loc215) +// CHECK-NEXT: } loc(#loc215) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc215) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc215) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc215) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc215) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc215) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc215) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc215) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc215) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc215) +// CHECK-NEXT: } loc(#loc215) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: return %3 : i256 loc(#loc216) +// CHECK-NEXT: } loc(#loc212) +// CHECK-NEXT: func.func @encode_array_calldata_address_674(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:172:39)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc218) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc218) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc218) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc219) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc220) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc220) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc220) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc220) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc220) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc220) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc220) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc220) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc220) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc220) +// CHECK-NEXT: %28 = arith.andi %27, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc220) +// CHECK-NEXT: %29 = arith.cmpi ne, %27, %28 : i256 loc(#loc220) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc220) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc220) +// CHECK-NEXT: } loc(#loc220) +// CHECK-NEXT: %30 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %28, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %31 = arith.addi %arg2, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: scf.yield %31, %32 : i256, i256 loc(#loc220) +// CHECK-NEXT: } loc(#loc220) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc220) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc220) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc220) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc220) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc220) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc220) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc220) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc220) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc220) +// CHECK-NEXT: } loc(#loc220) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: return %3 : i256 loc(#loc221) +// CHECK-NEXT: } loc(#loc217) +// CHECK-NEXT: func.func @encode_array_calldata_contract_689(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:176:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc223) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc223) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc223) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc224) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc225) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc225) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc225) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc225) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc225) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc225) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc225) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc225) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc225) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc225) +// CHECK-NEXT: %28 = arith.andi %27, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc225) +// CHECK-NEXT: %29 = arith.cmpi ne, %27, %28 : i256 loc(#loc225) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc225) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc225) +// CHECK-NEXT: } loc(#loc225) +// CHECK-NEXT: %30 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %28, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %31 = arith.addi %arg2, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: scf.yield %31, %32 : i256, i256 loc(#loc225) +// CHECK-NEXT: } loc(#loc225) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc225) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc225) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc225) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc225) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc225) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc225) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc225) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc225) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc225) +// CHECK-NEXT: } loc(#loc225) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: return %3 : i256 loc(#loc226) +// CHECK-NEXT: } loc(#loc222) +// CHECK-NEXT: func.func @encode_packed_calldata_array_bytes5_703(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:180:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc228) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc228) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc228) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc229) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc230) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc230) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc230) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc230) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc230) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc230) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc230) +// CHECK-NEXT: %22 = arith.andi %21, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc230) +// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc230) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc230) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc230) +// CHECK-NEXT: } loc(#loc230) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc230) +// CHECK-NEXT: } loc(#loc230) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc230) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc230) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc230) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc230) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc230) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc230) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc230) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc230) +// CHECK-NEXT: } loc(#loc230) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: return %3 : i256 loc(#loc231) +// CHECK-NEXT: } loc(#loc227) +// CHECK-NEXT: func.func @encode_array_calldata_bytes5_717(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:184:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc233) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc233) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc233) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc234) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc235) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc235) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc235) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc235) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc235) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc235) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc235) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc235) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc235) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc235) +// CHECK-NEXT: %28 = arith.andi %27, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc235) +// CHECK-NEXT: %29 = arith.cmpi ne, %27, %28 : i256 loc(#loc235) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc235) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc235) +// CHECK-NEXT: } loc(#loc235) +// CHECK-NEXT: %30 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %28, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %31 = arith.addi %arg2, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: scf.yield %31, %32 : i256, i256 loc(#loc235) +// CHECK-NEXT: } loc(#loc235) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc235) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc235) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc235) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc235) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc235) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc235) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc235) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc235) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc235) +// CHECK-NEXT: } loc(#loc235) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: return %3 : i256 loc(#loc236) +// CHECK-NEXT: } loc(#loc232) +// CHECK-NEXT: func.func @encode_selector_733(%arg0: i256 loc({{.*}}:188:25), %arg1: i256 loc({{.*}}:188:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc213) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc213) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc214) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc214) -// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc215) -// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc216) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc217) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc217) -// CHECK-NEXT: %7 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %8 = arith.addi %5, %c36_i256 : i256 loc(#loc217) -// CHECK-NEXT: %9 = arith.addi %5, %c68_i256 : i256 loc(#loc217) -// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %11 = arith.subi %9, %6 : i256 loc(#loc217) -// CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %13 = arith.addi %5, %c68_i256 : i256 loc(#loc217) -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: return %5 : i256 loc(#loc218) -// CHECK-NEXT: } loc(#loc212) -// CHECK-NEXT: func.func @encode_fnptr_659(%arg0: i256 loc({{.*}}:172:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc238) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc238) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc239) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc239) +// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc240) +// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc241) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc242) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc242) +// CHECK-NEXT: %7 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %8 = arith.addi %5, %c36_i256 : i256 loc(#loc242) +// CHECK-NEXT: %9 = arith.addi %5, %c68_i256 : i256 loc(#loc242) +// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %11 = arith.subi %9, %6 : i256 loc(#loc242) +// CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %13 = arith.addi %5, %c96_i256 : i256 loc(#loc242) +// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc242) +// CHECK-NEXT: %15 = arith.cmpi ult, %13, %5 : i256 loc(#loc242) +// CHECK-NEXT: %16 = arith.ori %14, %15 : i1 loc(#loc242) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %19 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %c65_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: "llvm.intrcall"(%20, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc242) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc242) +// CHECK-NEXT: } loc(#loc242) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %13, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: return %5 : i256 loc(#loc243) +// CHECK-NEXT: } loc(#loc237) +// CHECK-NEXT: func.func @encode_fnptr_752(%arg0: i256 loc({{.*}}:192:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-18446744073709551616_i256 = arith.constant -18446744073709551616 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc220) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc220) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc220) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc221) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc222) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc222) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc222) -// CHECK-NEXT: %6 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc222) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc222) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc222) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: return %3 : i256 loc(#loc223) -// CHECK-NEXT: } loc(#loc219) -// CHECK-NEXT: func.func @encode_packed_fnptr_678(%arg0: i256 loc({{.*}}:176:29)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc245) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc245) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc245) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc246) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc247) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc247) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc247) +// CHECK-NEXT: %6 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc247) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc247) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc247) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc247) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc247) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc247) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc247) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc247) +// CHECK-NEXT: } loc(#loc247) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: return %3 : i256 loc(#loc248) +// CHECK-NEXT: } loc(#loc244) +// CHECK-NEXT: func.func @encode_packed_fnptr_771(%arg0: i256 loc({{.*}}:196:29)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c56_i256 = arith.constant 56 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-18446744073709551616_i256 = arith.constant -18446744073709551616 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc225) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc225) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc225) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc226) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc227) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc227) -// CHECK-NEXT: %5 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc227) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: %7 = arith.addi %3, %c56_i256 : i256 loc(#loc227) -// CHECK-NEXT: %8 = arith.subi %7, %4 : i256 loc(#loc227) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: %10 = arith.addi %3, %c56_i256 : i256 loc(#loc227) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: return %3 : i256 loc(#loc228) -// CHECK-NEXT: } loc(#loc224) -// CHECK-NEXT: func.func @encode_packed_fnptr_array_698(%arg0: i256 loc({{.*}}:180:35)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc250) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc250) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc250) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc251) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc252) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc252) +// CHECK-NEXT: %5 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc252) +// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %7 = arith.addi %3, %c56_i256 : i256 loc(#loc252) +// CHECK-NEXT: %8 = arith.subi %7, %4 : i256 loc(#loc252) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc252) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc252) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc252) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc252) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc252) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc252) +// CHECK-NEXT: } loc(#loc252) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: return %3 : i256 loc(#loc253) +// CHECK-NEXT: } loc(#loc249) +// CHECK-NEXT: func.func @encode_packed_fnptr_array_791(%arg0: i256 loc({{.*}}:200:35)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c-18446744073709551616_i256 = arith.constant -18446744073709551616 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc230) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc230) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc230) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc231) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc232) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc232) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc232) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc232) -// CHECK-NEXT: %15 = arith.andi %14, %c-18446744073709551616_i256 : i256 loc(#loc232) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc232) -// CHECK-NEXT: } loc(#loc232) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc232) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: return %3 : i256 loc(#loc233) -// CHECK-NEXT: } loc(#loc229) -// CHECK-NEXT: func.func @CC_196() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc255) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc255) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc255) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc256) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc257) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc257) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc257) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc257) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc257) +// CHECK-NEXT: %23 = arith.andi %22, %c-18446744073709551616_i256 : i256 loc(#loc257) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc257) +// CHECK-NEXT: } loc(#loc257) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc257) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc257) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc257) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc257) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc257) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc257) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc257) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc257) +// CHECK-NEXT: } loc(#loc257) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: return %3 : i256 loc(#loc258) +// CHECK-NEXT: } loc(#loc254) +// CHECK-NEXT: func.func @CC_236() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: return loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: module @CC_196_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: module @CC_236_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { // CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) @@ -1899,7 +2989,7 @@ contract StorageBytes { // CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: func.call @foo_195() : () -> () loc(#loc1) +// CHECK-NEXT: func.call @foo_235() : () -> () loc(#loc1) // CHECK-NEXT: %10 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc1) @@ -1916,14 +3006,14 @@ contract StorageBytes { // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: func.func @foo_195() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: return loc(#loc234) -// CHECK-NEXT: } loc(#loc234) +// CHECK-NEXT: func.func @foo_235() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: return loc(#loc259) +// CHECK-NEXT: } loc(#loc259) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: #loc = loc(unknown) -// CHECK-NEXT: #loc1 = loc({{.*}}:46:0) -// CHECK-NEXT: #loc2 = loc({{.*}}:15:9) +// CHECK-NEXT: #loc1 = loc({{.*}}:54:0) +// CHECK-NEXT: #loc2 = loc({{.*}}:11:9) // CHECK-NEXT: #loc3 = loc({{.*}}:2:0) // CHECK-NEXT: #loc4 = loc({{.*}}:3:9) // CHECK-NEXT: #loc5 = loc({{.*}}:3:2) @@ -1934,19 +3024,19 @@ contract StorageBytes { // CHECK-NEXT: #loc13 = loc({{.*}}:11:20) // CHECK-NEXT: #loc14 = loc({{.*}}:11:24) // CHECK-NEXT: #loc15 = loc({{.*}}:11:29) -// CHECK-NEXT: #loc16 = loc({{.*}}:11:9) -// CHECK-NEXT: #loc17 = loc({{.*}}:11:2) -// CHECK-NEXT: #loc18 = loc({{.*}}:14:0) -// CHECK-NEXT: #loc20 = loc({{.*}}:15:20) +// CHECK-NEXT: #loc16 = loc({{.*}}:11:2) +// CHECK-NEXT: #loc17 = loc({{.*}}:14:0) +// CHECK-NEXT: #loc19 = loc({{.*}}:15:20) +// CHECK-NEXT: #loc20 = loc({{.*}}:15:9) // CHECK-NEXT: #loc21 = loc({{.*}}:15:2) // CHECK-NEXT: #loc22 = loc({{.*}}:18:0) -// CHECK-NEXT: #loc26 = loc({{.*}}:19:26) -// CHECK-NEXT: #loc27 = loc({{.*}}:19:29) -// CHECK-NEXT: #loc28 = loc({{.*}}:19:32) -// CHECK-NEXT: #loc29 = loc({{.*}}:19:9) -// CHECK-NEXT: #loc30 = loc({{.*}}:19:2) -// CHECK-NEXT: #loc31 = loc({{.*}}:22:0) -// CHECK-NEXT: #loc33 = loc({{.*}}:23:20) +// CHECK-NEXT: #loc24 = loc({{.*}}:19:20) +// CHECK-NEXT: #loc25 = loc({{.*}}:19:9) +// CHECK-NEXT: #loc26 = loc({{.*}}:19:2) +// CHECK-NEXT: #loc27 = loc({{.*}}:22:0) +// CHECK-NEXT: #loc31 = loc({{.*}}:23:26) +// CHECK-NEXT: #loc32 = loc({{.*}}:23:29) +// CHECK-NEXT: #loc33 = loc({{.*}}:23:32) // CHECK-NEXT: #loc34 = loc({{.*}}:23:9) // CHECK-NEXT: #loc35 = loc({{.*}}:23:2) // CHECK-NEXT: #loc36 = loc({{.*}}:26:0) @@ -1954,62 +3044,62 @@ contract StorageBytes { // CHECK-NEXT: #loc39 = loc({{.*}}:27:9) // CHECK-NEXT: #loc40 = loc({{.*}}:27:2) // CHECK-NEXT: #loc41 = loc({{.*}}:30:0) -// CHECK-NEXT: #loc43 = loc({{.*}}:31:26) +// CHECK-NEXT: #loc43 = loc({{.*}}:31:20) // CHECK-NEXT: #loc44 = loc({{.*}}:31:9) // CHECK-NEXT: #loc45 = loc({{.*}}:31:2) // CHECK-NEXT: #loc46 = loc({{.*}}:34:0) -// CHECK-NEXT: #loc48 = loc({{.*}}:35:31) -// CHECK-NEXT: #loc49 = loc({{.*}}:35:20) -// CHECK-NEXT: #loc50 = loc({{.*}}:35:9) -// CHECK-NEXT: #loc51 = loc({{.*}}:35:2) -// CHECK-NEXT: #loc52 = loc({{.*}}:38:0) -// CHECK-NEXT: #loc55 = loc({{.*}}:39:31) -// CHECK-NEXT: #loc56 = loc({{.*}}:39:34) -// CHECK-NEXT: #loc57 = loc({{.*}}:39:20) -// CHECK-NEXT: #loc58 = loc({{.*}}:39:9) -// CHECK-NEXT: #loc59 = loc({{.*}}:39:2) -// CHECK-NEXT: #loc60 = loc({{.*}}:42:0) -// CHECK-NEXT: #loc62 = loc({{.*}}:43:39) -// CHECK-NEXT: #loc63 = loc({{.*}}:43:20) -// CHECK-NEXT: #loc64 = loc({{.*}}:43:9) -// CHECK-NEXT: #loc65 = loc({{.*}}:43:2) -// CHECK-NEXT: #loc66 = loc({{.*}}:50:0) -// CHECK-NEXT: #loc68 = loc({{.*}}:51:20) -// CHECK-NEXT: #loc69 = loc({{.*}}:51:9) -// CHECK-NEXT: #loc70 = loc({{.*}}:51:2) -// CHECK-NEXT: #loc71 = loc({{.*}}:54:0) -// CHECK-NEXT: #loc73 = loc({{.*}}:55:26) -// CHECK-NEXT: #loc74 = loc({{.*}}:55:9) -// CHECK-NEXT: #loc75 = loc({{.*}}:55:2) +// CHECK-NEXT: #loc48 = loc({{.*}}:35:20) +// CHECK-NEXT: #loc49 = loc({{.*}}:35:9) +// CHECK-NEXT: #loc50 = loc({{.*}}:35:2) +// CHECK-NEXT: #loc51 = loc({{.*}}:38:0) +// CHECK-NEXT: #loc53 = loc({{.*}}:39:26) +// CHECK-NEXT: #loc54 = loc({{.*}}:39:9) +// CHECK-NEXT: #loc55 = loc({{.*}}:39:2) +// CHECK-NEXT: #loc56 = loc({{.*}}:42:0) +// CHECK-NEXT: #loc58 = loc({{.*}}:43:31) +// CHECK-NEXT: #loc59 = loc({{.*}}:43:20) +// CHECK-NEXT: #loc60 = loc({{.*}}:43:9) +// CHECK-NEXT: #loc61 = loc({{.*}}:43:2) +// CHECK-NEXT: #loc62 = loc({{.*}}:46:0) +// CHECK-NEXT: #loc65 = loc({{.*}}:47:31) +// CHECK-NEXT: #loc66 = loc({{.*}}:47:34) +// CHECK-NEXT: #loc67 = loc({{.*}}:47:20) +// CHECK-NEXT: #loc68 = loc({{.*}}:47:9) +// CHECK-NEXT: #loc69 = loc({{.*}}:47:2) +// CHECK-NEXT: #loc70 = loc({{.*}}:50:0) +// CHECK-NEXT: #loc72 = loc({{.*}}:51:39) +// CHECK-NEXT: #loc73 = loc({{.*}}:51:20) +// CHECK-NEXT: #loc74 = loc({{.*}}:51:9) +// CHECK-NEXT: #loc75 = loc({{.*}}:51:2) // CHECK-NEXT: #loc76 = loc({{.*}}:58:0) // CHECK-NEXT: #loc78 = loc({{.*}}:59:20) // CHECK-NEXT: #loc79 = loc({{.*}}:59:9) // CHECK-NEXT: #loc80 = loc({{.*}}:59:2) // CHECK-NEXT: #loc81 = loc({{.*}}:62:0) -// CHECK-NEXT: #loc83 = loc({{.*}}:63:31) -// CHECK-NEXT: #loc84 = loc({{.*}}:63:20) -// CHECK-NEXT: #loc85 = loc({{.*}}:63:9) -// CHECK-NEXT: #loc86 = loc({{.*}}:63:2) -// CHECK-NEXT: #loc87 = loc({{.*}}:66:0) -// CHECK-NEXT: #loc89 = loc({{.*}}:67:20) -// CHECK-NEXT: #loc90 = loc({{.*}}:67:9) -// CHECK-NEXT: #loc91 = loc({{.*}}:67:2) -// CHECK-NEXT: #loc92 = loc({{.*}}:72:0) -// CHECK-NEXT: #loc94 = loc({{.*}}:73:26) -// CHECK-NEXT: #loc95 = loc({{.*}}:73:9) -// CHECK-NEXT: #loc96 = loc({{.*}}:73:2) -// CHECK-NEXT: #loc97 = loc({{.*}}:76:0) -// CHECK-NEXT: #loc99 = loc({{.*}}:77:26) -// CHECK-NEXT: #loc100 = loc({{.*}}:77:9) -// CHECK-NEXT: #loc101 = loc({{.*}}:77:2) -// CHECK-NEXT: #loc102 = loc({{.*}}:80:0) -// CHECK-NEXT: #loc104 = loc({{.*}}:81:26) -// CHECK-NEXT: #loc105 = loc({{.*}}:81:9) -// CHECK-NEXT: #loc106 = loc({{.*}}:81:2) -// CHECK-NEXT: #loc107 = loc({{.*}}:84:0) -// CHECK-NEXT: #loc109 = loc({{.*}}:85:26) -// CHECK-NEXT: #loc110 = loc({{.*}}:85:9) -// CHECK-NEXT: #loc111 = loc({{.*}}:85:2) +// CHECK-NEXT: #loc83 = loc({{.*}}:63:26) +// CHECK-NEXT: #loc84 = loc({{.*}}:63:9) +// CHECK-NEXT: #loc85 = loc({{.*}}:63:2) +// CHECK-NEXT: #loc86 = loc({{.*}}:66:0) +// CHECK-NEXT: #loc88 = loc({{.*}}:67:20) +// CHECK-NEXT: #loc89 = loc({{.*}}:67:9) +// CHECK-NEXT: #loc90 = loc({{.*}}:67:2) +// CHECK-NEXT: #loc91 = loc({{.*}}:70:0) +// CHECK-NEXT: #loc93 = loc({{.*}}:71:20) +// CHECK-NEXT: #loc94 = loc({{.*}}:71:9) +// CHECK-NEXT: #loc95 = loc({{.*}}:71:2) +// CHECK-NEXT: #loc96 = loc({{.*}}:74:0) +// CHECK-NEXT: #loc98 = loc({{.*}}:75:31) +// CHECK-NEXT: #loc99 = loc({{.*}}:75:20) +// CHECK-NEXT: #loc100 = loc({{.*}}:75:9) +// CHECK-NEXT: #loc101 = loc({{.*}}:75:2) +// CHECK-NEXT: #loc102 = loc({{.*}}:78:0) +// CHECK-NEXT: #loc104 = loc({{.*}}:79:20) +// CHECK-NEXT: #loc105 = loc({{.*}}:79:9) +// CHECK-NEXT: #loc106 = loc({{.*}}:79:2) +// CHECK-NEXT: #loc107 = loc({{.*}}:82:0) +// CHECK-NEXT: #loc109 = loc({{.*}}:83:20) +// CHECK-NEXT: #loc110 = loc({{.*}}:83:9) +// CHECK-NEXT: #loc111 = loc({{.*}}:83:2) // CHECK-NEXT: #loc112 = loc({{.*}}:88:0) // CHECK-NEXT: #loc114 = loc({{.*}}:89:26) // CHECK-NEXT: #loc115 = loc({{.*}}:89:9) @@ -2043,19 +3133,19 @@ contract StorageBytes { // CHECK-NEXT: #loc150 = loc({{.*}}:117:9) // CHECK-NEXT: #loc151 = loc({{.*}}:117:2) // CHECK-NEXT: #loc152 = loc({{.*}}:120:0) -// CHECK-NEXT: #loc154 = loc({{.*}}:121:20) +// CHECK-NEXT: #loc154 = loc({{.*}}:121:26) // CHECK-NEXT: #loc155 = loc({{.*}}:121:9) // CHECK-NEXT: #loc156 = loc({{.*}}:121:2) // CHECK-NEXT: #loc157 = loc({{.*}}:124:0) -// CHECK-NEXT: #loc159 = loc({{.*}}:125:20) +// CHECK-NEXT: #loc159 = loc({{.*}}:125:26) // CHECK-NEXT: #loc160 = loc({{.*}}:125:9) // CHECK-NEXT: #loc161 = loc({{.*}}:125:2) // CHECK-NEXT: #loc162 = loc({{.*}}:128:0) -// CHECK-NEXT: #loc164 = loc({{.*}}:129:20) +// CHECK-NEXT: #loc164 = loc({{.*}}:129:26) // CHECK-NEXT: #loc165 = loc({{.*}}:129:9) // CHECK-NEXT: #loc166 = loc({{.*}}:129:2) // CHECK-NEXT: #loc167 = loc({{.*}}:132:0) -// CHECK-NEXT: #loc169 = loc({{.*}}:133:20) +// CHECK-NEXT: #loc169 = loc({{.*}}:133:26) // CHECK-NEXT: #loc170 = loc({{.*}}:133:9) // CHECK-NEXT: #loc171 = loc({{.*}}:133:2) // CHECK-NEXT: #loc172 = loc({{.*}}:136:0) @@ -2083,7 +3173,7 @@ contract StorageBytes { // CHECK-NEXT: #loc200 = loc({{.*}}:157:9) // CHECK-NEXT: #loc201 = loc({{.*}}:157:2) // CHECK-NEXT: #loc202 = loc({{.*}}:160:0) -// CHECK-NEXT: #loc204 = loc({{.*}}:161:26) +// CHECK-NEXT: #loc204 = loc({{.*}}:161:20) // CHECK-NEXT: #loc205 = loc({{.*}}:161:9) // CHECK-NEXT: #loc206 = loc({{.*}}:161:2) // CHECK-NEXT: #loc207 = loc({{.*}}:164:0) @@ -2091,75 +3181,107 @@ contract StorageBytes { // CHECK-NEXT: #loc210 = loc({{.*}}:165:9) // CHECK-NEXT: #loc211 = loc({{.*}}:165:2) // CHECK-NEXT: #loc212 = loc({{.*}}:168:0) -// CHECK-NEXT: #loc215 = loc({{.*}}:169:32) -// CHECK-NEXT: #loc216 = loc({{.*}}:169:37) -// CHECK-NEXT: #loc217 = loc({{.*}}:169:9) -// CHECK-NEXT: #loc218 = loc({{.*}}:169:2) -// CHECK-NEXT: #loc219 = loc({{.*}}:172:0) -// CHECK-NEXT: #loc221 = loc({{.*}}:173:20) -// CHECK-NEXT: #loc222 = loc({{.*}}:173:9) -// CHECK-NEXT: #loc223 = loc({{.*}}:173:2) -// CHECK-NEXT: #loc224 = loc({{.*}}:176:0) -// CHECK-NEXT: #loc226 = loc({{.*}}:177:26) -// CHECK-NEXT: #loc227 = loc({{.*}}:177:9) -// CHECK-NEXT: #loc228 = loc({{.*}}:177:2) -// CHECK-NEXT: #loc229 = loc({{.*}}:180:0) -// CHECK-NEXT: #loc231 = loc({{.*}}:181:26) -// CHECK-NEXT: #loc232 = loc({{.*}}:181:9) -// CHECK-NEXT: #loc233 = loc({{.*}}:181:2) -// CHECK-NEXT: #loc234 = loc({{.*}}:47:2) +// CHECK-NEXT: #loc214 = loc({{.*}}:169:20) +// CHECK-NEXT: #loc215 = loc({{.*}}:169:9) +// CHECK-NEXT: #loc216 = loc({{.*}}:169:2) +// CHECK-NEXT: #loc217 = loc({{.*}}:172:0) +// CHECK-NEXT: #loc219 = loc({{.*}}:173:20) +// CHECK-NEXT: #loc220 = loc({{.*}}:173:9) +// CHECK-NEXT: #loc221 = loc({{.*}}:173:2) +// CHECK-NEXT: #loc222 = loc({{.*}}:176:0) +// CHECK-NEXT: #loc224 = loc({{.*}}:177:20) +// CHECK-NEXT: #loc225 = loc({{.*}}:177:9) +// CHECK-NEXT: #loc226 = loc({{.*}}:177:2) +// CHECK-NEXT: #loc227 = loc({{.*}}:180:0) +// CHECK-NEXT: #loc229 = loc({{.*}}:181:26) +// CHECK-NEXT: #loc230 = loc({{.*}}:181:9) +// CHECK-NEXT: #loc231 = loc({{.*}}:181:2) +// CHECK-NEXT: #loc232 = loc({{.*}}:184:0) +// CHECK-NEXT: #loc234 = loc({{.*}}:185:20) +// CHECK-NEXT: #loc235 = loc({{.*}}:185:9) +// CHECK-NEXT: #loc236 = loc({{.*}}:185:2) +// CHECK-NEXT: #loc237 = loc({{.*}}:188:0) +// CHECK-NEXT: #loc240 = loc({{.*}}:189:32) +// CHECK-NEXT: #loc241 = loc({{.*}}:189:37) +// CHECK-NEXT: #loc242 = loc({{.*}}:189:9) +// CHECK-NEXT: #loc243 = loc({{.*}}:189:2) +// CHECK-NEXT: #loc244 = loc({{.*}}:192:0) +// CHECK-NEXT: #loc246 = loc({{.*}}:193:20) +// CHECK-NEXT: #loc247 = loc({{.*}}:193:9) +// CHECK-NEXT: #loc248 = loc({{.*}}:193:2) +// CHECK-NEXT: #loc249 = loc({{.*}}:196:0) +// CHECK-NEXT: #loc251 = loc({{.*}}:197:26) +// CHECK-NEXT: #loc252 = loc({{.*}}:197:9) +// CHECK-NEXT: #loc253 = loc({{.*}}:197:2) +// CHECK-NEXT: #loc254 = loc({{.*}}:200:0) +// CHECK-NEXT: #loc256 = loc({{.*}}:201:26) +// CHECK-NEXT: #loc257 = loc({{.*}}:201:9) +// CHECK-NEXT: #loc258 = loc({{.*}}:201:2) +// CHECK-NEXT: #loc259 = loc({{.*}}:55:2) // CHECK-NEXT: #Osaka = #sol // CHECK-NEXT: #loc10 = loc({{.*}}:10:16) // CHECK-NEXT: #loc11 = loc({{.*}}:10:25) // CHECK-NEXT: #loc12 = loc({{.*}}:10:36) -// CHECK-NEXT: #loc19 = loc({{.*}}:14:16) -// CHECK-NEXT: #loc23 = loc({{.*}}:18:23) -// CHECK-NEXT: #loc24 = loc({{.*}}:18:33) -// CHECK-NEXT: #loc25 = loc({{.*}}:18:43) -// CHECK-NEXT: #loc32 = loc({{.*}}:22:21) +// CHECK-NEXT: #loc18 = loc({{.*}}:14:16) +// CHECK-NEXT: #loc23 = loc({{.*}}:18:25) +// CHECK-NEXT: #loc28 = loc({{.*}}:22:23) +// CHECK-NEXT: #loc29 = loc({{.*}}:22:33) +// CHECK-NEXT: #loc30 = loc({{.*}}:22:43) // CHECK-NEXT: #loc37 = loc({{.*}}:26:21) -// CHECK-NEXT: #loc42 = loc({{.*}}:30:28) -// CHECK-NEXT: #loc47 = loc({{.*}}:34:24) -// CHECK-NEXT: #loc53 = loc({{.*}}:38:30) -// CHECK-NEXT: #loc54 = loc({{.*}}:38:41) -// CHECK-NEXT: #loc61 = loc({{.*}}:42:32) -// CHECK-NEXT: #loc67 = loc({{.*}}:50:25) -// CHECK-NEXT: #loc72 = loc({{.*}}:54:32) +// CHECK-NEXT: #loc42 = loc({{.*}}:30:21) +// CHECK-NEXT: #loc47 = loc({{.*}}:34:30) +// CHECK-NEXT: #loc52 = loc({{.*}}:38:28) +// CHECK-NEXT: #loc57 = loc({{.*}}:42:24) +// CHECK-NEXT: #loc63 = loc({{.*}}:46:30) +// CHECK-NEXT: #loc64 = loc({{.*}}:46:41) +// CHECK-NEXT: #loc71 = loc({{.*}}:50:32) // CHECK-NEXT: #loc77 = loc({{.*}}:58:25) -// CHECK-NEXT: #loc82 = loc({{.*}}:62:28) -// CHECK-NEXT: #loc88 = loc({{.*}}:66:31) -// CHECK-NEXT: #loc93 = loc({{.*}}:72:36) -// CHECK-NEXT: #loc98 = loc({{.*}}:76:38) -// CHECK-NEXT: #loc103 = loc({{.*}}:80:34) -// CHECK-NEXT: #loc108 = loc({{.*}}:84:34) -// CHECK-NEXT: #loc113 = loc({{.*}}:88:37) -// CHECK-NEXT: #loc118 = loc({{.*}}:92:40) -// CHECK-NEXT: #loc123 = loc({{.*}}:96:45) -// CHECK-NEXT: #loc128 = loc({{.*}}:100:47) -// CHECK-NEXT: #loc133 = loc({{.*}}:104:43) -// CHECK-NEXT: #loc138 = loc({{.*}}:108:43) -// CHECK-NEXT: #loc143 = loc({{.*}}:112:46) +// CHECK-NEXT: #loc82 = loc({{.*}}:62:32) +// CHECK-NEXT: #loc87 = loc({{.*}}:66:25) +// CHECK-NEXT: #loc92 = loc({{.*}}:70:34) +// CHECK-NEXT: #loc97 = loc({{.*}}:74:28) +// CHECK-NEXT: #loc103 = loc({{.*}}:78:31) +// CHECK-NEXT: #loc108 = loc({{.*}}:82:40) +// CHECK-NEXT: #loc113 = loc({{.*}}:88:36) +// CHECK-NEXT: #loc118 = loc({{.*}}:92:38) +// CHECK-NEXT: #loc123 = loc({{.*}}:96:34) +// CHECK-NEXT: #loc128 = loc({{.*}}:100:34) +// CHECK-NEXT: #loc133 = loc({{.*}}:104:37) +// CHECK-NEXT: #loc138 = loc({{.*}}:108:40) +// CHECK-NEXT: #loc143 = loc({{.*}}:112:45) // CHECK-NEXT: #loc148 = loc({{.*}}:116:47) -// CHECK-NEXT: #loc153 = loc({{.*}}:120:21) -// CHECK-NEXT: #loc158 = loc({{.*}}:124:22) -// CHECK-NEXT: #loc163 = loc({{.*}}:128:21) -// CHECK-NEXT: #loc168 = loc({{.*}}:132:23) -// CHECK-NEXT: #loc173 = loc({{.*}}:136:40) -// CHECK-NEXT: #loc178 = loc({{.*}}:140:47) -// CHECK-NEXT: #loc183 = loc({{.*}}:144:36) -// CHECK-NEXT: #loc188 = loc({{.*}}:148:36) -// CHECK-NEXT: #loc193 = loc({{.*}}:152:39) -// CHECK-NEXT: #loc198 = loc({{.*}}:156:40) -// CHECK-NEXT: #loc203 = loc({{.*}}:160:45) -// CHECK-NEXT: #loc208 = loc({{.*}}:164:38) -// CHECK-NEXT: #loc213 = loc({{.*}}:168:25) -// CHECK-NEXT: #loc214 = loc({{.*}}:168:37) -// CHECK-NEXT: #loc220 = loc({{.*}}:172:22) -// CHECK-NEXT: #loc225 = loc({{.*}}:176:29) -// CHECK-NEXT: #loc230 = loc({{.*}}:180:35) -// CHECK-NEXT: #loc235 = loc({{.*}}:196:35) -// CHECK-NEXT: module @StorageBytes_740 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: #loc153 = loc({{.*}}:120:43) +// CHECK-NEXT: #loc158 = loc({{.*}}:124:43) +// CHECK-NEXT: #loc163 = loc({{.*}}:128:46) +// CHECK-NEXT: #loc168 = loc({{.*}}:132:47) +// CHECK-NEXT: #loc173 = loc({{.*}}:136:21) +// CHECK-NEXT: #loc178 = loc({{.*}}:140:22) +// CHECK-NEXT: #loc183 = loc({{.*}}:144:21) +// CHECK-NEXT: #loc188 = loc({{.*}}:148:23) +// CHECK-NEXT: #loc193 = loc({{.*}}:152:40) +// CHECK-NEXT: #loc198 = loc({{.*}}:156:47) +// CHECK-NEXT: #loc203 = loc({{.*}}:160:20) +// CHECK-NEXT: #loc208 = loc({{.*}}:164:36) +// CHECK-NEXT: #loc213 = loc({{.*}}:168:36) +// CHECK-NEXT: #loc218 = loc({{.*}}:172:39) +// CHECK-NEXT: #loc223 = loc({{.*}}:176:40) +// CHECK-NEXT: #loc228 = loc({{.*}}:180:45) +// CHECK-NEXT: #loc233 = loc({{.*}}:184:38) +// CHECK-NEXT: #loc238 = loc({{.*}}:188:25) +// CHECK-NEXT: #loc239 = loc({{.*}}:188:37) +// CHECK-NEXT: #loc245 = loc({{.*}}:192:22) +// CHECK-NEXT: #loc250 = loc({{.*}}:196:29) +// CHECK-NEXT: #loc255 = loc({{.*}}:200:35) +// CHECK-NEXT: #loc260 = loc({{.*}}:216:35) +// CHECK-NEXT: module @StorageBytes_833 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -2168,31 +3290,45 @@ contract StorageBytes { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["StorageBytes_740"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["StorageBytes_833"], name = "evm.datasize"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %4 = "llvm.intrcall"() <{id = 4042 : i32, name = "evm.codesize"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: call @StorageBytes_740() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["StorageBytes_740_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["StorageBytes_740_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: call @StorageBytes_833() : () -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["StorageBytes_833_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["StorageBytes_833_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -2210,6 +3346,12 @@ contract StorageBytes { // CHECK-NEXT: func.func @encode_39(%arg0: i256 loc({{.*}}:10:16), %arg1: i8 loc({{.*}}:10:25), %arg2: i32 loc({{.*}}:10:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) @@ -2222,408 +3364,566 @@ contract StorageBytes { // CHECK-NEXT: %3 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc13) // CHECK-NEXT: %4 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i8 loc(#loc14) // CHECK-NEXT: %5 = llvm.load %2 {alignment = 32 : i64} : !llvm.ptr -> i32 loc(#loc15) -// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc16) -// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc16) -// CHECK-NEXT: %9 = arith.addi %7, %c128_i256 : i256 loc(#loc16) -// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %11 = arith.addi %7, %c64_i256 : i256 loc(#loc16) -// CHECK-NEXT: %12 = arith.extui %4 : i8 to i256 loc(#loc16) -// CHECK-NEXT: %13 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %14 = arith.addi %7, %c96_i256 : i256 loc(#loc16) -// CHECK-NEXT: %15 = arith.extsi %5 : i32 to i256 loc(#loc16) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %17 = arith.subi %9, %8 : i256 loc(#loc16) -// CHECK-NEXT: %18 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: %19 = arith.addi %7, %c128_i256 : i256 loc(#loc16) -// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: llvm.store %19, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc16) -// CHECK-NEXT: return %7 : i256 loc(#loc17) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %9 = arith.addi %7, %c128_i256 : i256 loc(#loc2) +// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %11 = arith.addi %7, %c64_i256 : i256 loc(#loc2) +// CHECK-NEXT: %12 = arith.extui %4 : i8 to i256 loc(#loc2) +// CHECK-NEXT: %13 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %14 = arith.addi %7, %c96_i256 : i256 loc(#loc2) +// CHECK-NEXT: %15 = arith.extsi %5 : i32 to i256 loc(#loc2) +// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %17 = arith.subi %9, %8 : i256 loc(#loc2) +// CHECK-NEXT: %18 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %17, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %19 = arith.addi %7, %c128_i256 : i256 loc(#loc2) +// CHECK-NEXT: %20 = arith.cmpi ugt, %19, %c18446744073709551615_i256 : i256 loc(#loc2) +// CHECK-NEXT: %21 = arith.cmpi ult, %19, %7 : i256 loc(#loc2) +// CHECK-NEXT: %22 = arith.ori %20, %21 : i1 loc(#loc2) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %23 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %19, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: return %7 : i256 loc(#loc16) // CHECK-NEXT: } loc(#loc9) // CHECK-NEXT: func.func @decode_63(%arg0: i256 loc({{.*}}:14:16)) -> (i256, i8, i32) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc19) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc19) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc19) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc20) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc2) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c96_i256 : i256 loc(#loc2) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc18) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc18) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc18) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc19) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c96_i256 : i256 loc(#loc20) // CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) -// CHECK-NEXT: } loc(#loc2) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %8 = arith.addi %1, %c64_i256 : i256 loc(#loc2) -// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %11 = arith.trunci %10 : i256 to i8 loc(#loc2) -// CHECK-NEXT: %12 = arith.extui %11 : i8 to i256 loc(#loc2) -// CHECK-NEXT: %13 = arith.cmpi ne, %10, %12 : i256 loc(#loc2) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %8 = arith.addi %1, %c64_i256 : i256 loc(#loc20) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %11 = arith.trunci %10 : i256 to i8 loc(#loc20) +// CHECK-NEXT: %12 = arith.extui %11 : i8 to i256 loc(#loc20) +// CHECK-NEXT: %13 = arith.cmpi ne, %10, %12 : i256 loc(#loc20) // CHECK-NEXT: scf.if %13 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) -// CHECK-NEXT: } loc(#loc2) -// CHECK-NEXT: %14 = arith.addi %1, %c96_i256 : i256 loc(#loc2) -// CHECK-NEXT: %15 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) -// CHECK-NEXT: %17 = arith.trunci %16 : i256 to i32 loc(#loc2) -// CHECK-NEXT: %18 = arith.extsi %17 : i32 to i256 loc(#loc2) -// CHECK-NEXT: %19 = arith.cmpi ne, %16, %18 : i256 loc(#loc2) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) +// CHECK-NEXT: %14 = arith.addi %1, %c96_i256 : i256 loc(#loc20) +// CHECK-NEXT: %15 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %17 = arith.trunci %16 : i256 to i32 loc(#loc20) +// CHECK-NEXT: %18 = arith.extsi %17 : i32 to i256 loc(#loc20) +// CHECK-NEXT: %19 = arith.cmpi ne, %16, %18 : i256 loc(#loc20) // CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) -// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) +// CHECK-NEXT: } loc(#loc20) // CHECK-NEXT: return %7, %11, %17 : i256, i8, i32 loc(#loc21) -// CHECK-NEXT: } loc(#loc18) -// CHECK-NEXT: func.func @encode_packed_82(%arg0: i24 loc({{.*}}:18:23), %arg1: i96 loc({{.*}}:18:33), %arg2: i136 loc({{.*}}:18:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: } loc(#loc17) +// CHECK-NEXT: func.func @decode_calldata_87(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:18:25)) -> (i256, i8, i32) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc23) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc23) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc23) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc24) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc25) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc25) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c96_i256 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc25) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc25) +// CHECK-NEXT: %7 = arith.addi %2, %c32_i256 : i256 loc(#loc25) +// CHECK-NEXT: %8 = llvm.inttoptr %7 : i256 to !llvm.ptr<2> loc(#loc25) +// CHECK-NEXT: %9 = llvm.load %8 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc25) +// CHECK-NEXT: %10 = arith.trunci %9 : i256 to i8 loc(#loc25) +// CHECK-NEXT: %11 = arith.extui %10 : i8 to i256 loc(#loc25) +// CHECK-NEXT: %12 = arith.cmpi ne, %9, %11 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: %13 = arith.addi %2, %c64_i256 : i256 loc(#loc25) +// CHECK-NEXT: %14 = llvm.inttoptr %13 : i256 to !llvm.ptr<2> loc(#loc25) +// CHECK-NEXT: %15 = llvm.load %14 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc25) +// CHECK-NEXT: %16 = arith.trunci %15 : i256 to i32 loc(#loc25) +// CHECK-NEXT: %17 = arith.extsi %16 : i32 to i256 loc(#loc25) +// CHECK-NEXT: %18 = arith.cmpi ne, %15, %17 : i256 loc(#loc25) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc25) +// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc25) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc25) +// CHECK-NEXT: } loc(#loc25) +// CHECK-NEXT: return %6, %10, %16 : i256, i8, i32 loc(#loc26) +// CHECK-NEXT: } loc(#loc22) +// CHECK-NEXT: func.func @encode_packed_106(%arg0: i24 loc({{.*}}:22:23), %arg1: i96 loc({{.*}}:22:33), %arg2: i136 loc({{.*}}:22:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c47_i256 = arith.constant 47 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c120_i256 = arith.constant 120 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c232_i256 = arith.constant 232 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i24 : (i256) -> !llvm.ptr loc(#loc23) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i24, !llvm.ptr loc(#loc23) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i96 : (i256) -> !llvm.ptr loc(#loc24) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i96, !llvm.ptr loc(#loc24) -// CHECK-NEXT: %2 = llvm.alloca %c1_i256 x i136 : (i256) -> !llvm.ptr loc(#loc25) -// CHECK-NEXT: llvm.store %arg2, %2 {alignment = 32 : i64} : i136, !llvm.ptr loc(#loc25) -// CHECK-NEXT: %3 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i24 loc(#loc26) -// CHECK-NEXT: %4 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i96 loc(#loc27) -// CHECK-NEXT: %5 = llvm.load %2 {alignment = 32 : i64} : !llvm.ptr -> i136 loc(#loc28) -// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc29) -// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc29) -// CHECK-NEXT: %9 = arith.extui %3 : i24 to i256 loc(#loc29) -// CHECK-NEXT: %10 = arith.shli %9, %c232_i256 : i256 loc(#loc29) -// CHECK-NEXT: %11 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %12 = arith.addi %7, %c35_i256 : i256 loc(#loc29) -// CHECK-NEXT: %13 = arith.extui %4 : i96 to i256 loc(#loc29) -// CHECK-NEXT: %14 = arith.shli %13, %c160_i256 : i256 loc(#loc29) -// CHECK-NEXT: %15 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %16 = arith.addi %7, %c47_i256 : i256 loc(#loc29) -// CHECK-NEXT: %17 = arith.extui %5 : i136 to i256 loc(#loc29) -// CHECK-NEXT: %18 = arith.shli %17, %c120_i256 : i256 loc(#loc29) -// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %20 = arith.addi %7, %c64_i256 : i256 loc(#loc29) -// CHECK-NEXT: %21 = arith.subi %20, %8 : i256 loc(#loc29) -// CHECK-NEXT: %22 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: %23 = arith.addi %7, %c64_i256 : i256 loc(#loc29) -// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc29) -// CHECK-NEXT: return %7 : i256 loc(#loc30) -// CHECK-NEXT: } loc(#loc22) -// CHECK-NEXT: func.func @encode_addr_95(%arg0: i256 loc({{.*}}:22:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc32) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc32) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc32) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc33) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc34) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc34) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc34) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc34) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc34) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i24 : (i256) -> !llvm.ptr loc(#loc28) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i24, !llvm.ptr loc(#loc28) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i96 : (i256) -> !llvm.ptr loc(#loc29) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i96, !llvm.ptr loc(#loc29) +// CHECK-NEXT: %2 = llvm.alloca %c1_i256 x i136 : (i256) -> !llvm.ptr loc(#loc30) +// CHECK-NEXT: llvm.store %arg2, %2 {alignment = 32 : i64} : i136, !llvm.ptr loc(#loc30) +// CHECK-NEXT: %3 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i24 loc(#loc31) +// CHECK-NEXT: %4 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i96 loc(#loc32) +// CHECK-NEXT: %5 = llvm.load %2 {alignment = 32 : i64} : !llvm.ptr -> i136 loc(#loc33) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc34) +// CHECK-NEXT: %8 = arith.addi %7, %c32_i256 : i256 loc(#loc34) +// CHECK-NEXT: %9 = arith.extui %3 : i24 to i256 loc(#loc34) +// CHECK-NEXT: %10 = arith.shli %9, %c232_i256 : i256 loc(#loc34) +// CHECK-NEXT: %11 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc34) // CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) -// CHECK-NEXT: return %3 : i256 loc(#loc35) -// CHECK-NEXT: } loc(#loc31) -// CHECK-NEXT: func.func @decode_addr_111(%arg0: i256 loc({{.*}}:26:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %12 = arith.addi %7, %c35_i256 : i256 loc(#loc34) +// CHECK-NEXT: %13 = arith.extui %4 : i96 to i256 loc(#loc34) +// CHECK-NEXT: %14 = arith.shli %13, %c160_i256 : i256 loc(#loc34) +// CHECK-NEXT: %15 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %16 = arith.addi %7, %c47_i256 : i256 loc(#loc34) +// CHECK-NEXT: %17 = arith.extui %5 : i136 to i256 loc(#loc34) +// CHECK-NEXT: %18 = arith.shli %17, %c120_i256 : i256 loc(#loc34) +// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %20 = arith.addi %7, %c64_i256 : i256 loc(#loc34) +// CHECK-NEXT: %21 = arith.subi %20, %8 : i256 loc(#loc34) +// CHECK-NEXT: %22 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %21, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %23 = arith.addi %7, %c64_i256 : i256 loc(#loc34) +// CHECK-NEXT: %24 = arith.cmpi ugt, %23, %c18446744073709551615_i256 : i256 loc(#loc34) +// CHECK-NEXT: %25 = arith.cmpi ult, %23, %7 : i256 loc(#loc34) +// CHECK-NEXT: %26 = arith.ori %24, %25 : i1 loc(#loc34) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %29 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %c65_i256, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: "llvm.intrcall"(%30, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc34) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc34) +// CHECK-NEXT: } loc(#loc34) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc34) +// CHECK-NEXT: return %7 : i256 loc(#loc35) +// CHECK-NEXT: } loc(#loc27) +// CHECK-NEXT: func.func @encode_addr_119(%arg0: i256 loc({{.*}}:26:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc37) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc37) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc37) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc38) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc39) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc39) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc39) -// CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) -// CHECK-NEXT: } loc(#loc39) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc39) -// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc39) -// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc39) -// CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc39) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc39) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc39) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc39) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc39) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc39) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc39) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc39) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc39) // CHECK-NEXT: } loc(#loc39) -// CHECK-NEXT: return %8 : i256 loc(#loc40) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc39) +// CHECK-NEXT: return %3 : i256 loc(#loc40) // CHECK-NEXT: } loc(#loc36) -// CHECK-NEXT: func.func @encode_packed_addr_124(%arg0: i256 loc({{.*}}:30:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @decode_addr_135(%arg0: i256 loc({{.*}}:30:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc42) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc42) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc42) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc43) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc44) -// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc44) -// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc44) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc44) -// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc44) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: %11 = arith.addi %3, %c52_i256 : i256 loc(#loc44) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc44) -// CHECK-NEXT: return %3 : i256 loc(#loc45) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc44) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc44) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc44) +// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc44) +// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc44) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc44) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc44) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc44) +// CHECK-NEXT: } loc(#loc44) +// CHECK-NEXT: return %8 : i256 loc(#loc45) // CHECK-NEXT: } loc(#loc41) -// CHECK-NEXT: func.func @roundtrip_addr_143(%arg0: i256 loc({{.*}}:34:24)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: func.func @decode_addr_calldata_151(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:34:30)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc47) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc47) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc47) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc48) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc49) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc49) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc49) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc49) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc49) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc49) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc49) -// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %14 = arith.addi %3, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: %15 = arith.cmpi slt, %13, %c32_i256 : i256 loc(#loc50) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) -// CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc50) -// CHECK-NEXT: %18 = arith.andi %17, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc50) -// CHECK-NEXT: %19 = arith.cmpi ne, %17, %18 : i256 loc(#loc50) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc50) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc50) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc50) -// CHECK-NEXT: } loc(#loc50) -// CHECK-NEXT: return %18 : i256 loc(#loc51) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc47) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc47) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc48) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc49) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc49) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc49) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc49) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc49) +// CHECK-NEXT: } loc(#loc49) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc49) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc49) +// CHECK-NEXT: %7 = arith.andi %6, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc49) +// CHECK-NEXT: %8 = arith.cmpi ne, %6, %7 : i256 loc(#loc49) +// CHECK-NEXT: scf.if %8 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc49) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc49) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc49) +// CHECK-NEXT: } loc(#loc49) +// CHECK-NEXT: return %7 : i256 loc(#loc50) // CHECK-NEXT: } loc(#loc46) -// CHECK-NEXT: func.func @roundtrip_addr_tuple_169(%arg0: i256 loc({{.*}}:38:30), %arg1: i256 loc({{.*}}:38:41)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_addr_164(%arg0: i256 loc({{.*}}:38:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc53) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc53) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc54) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc54) -// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc55) -// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc56) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc57) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc57) -// CHECK-NEXT: %7 = arith.addi %5, %c96_i256 : i256 loc(#loc57) -// CHECK-NEXT: %8 = arith.andi %2, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc57) -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %10 = arith.addi %5, %c64_i256 : i256 loc(#loc57) -// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %3, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %12 = arith.subi %7, %6 : i256 loc(#loc57) -// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %14 = arith.addi %5, %c96_i256 : i256 loc(#loc57) -// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: llvm.store %14, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc57) -// CHECK-NEXT: %16 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc58) -// CHECK-NEXT: %18 = arith.addi %5, %c32_i256 : i256 loc(#loc58) -// CHECK-NEXT: %19 = arith.cmpi slt, %17, %c64_i256 : i256 loc(#loc58) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc58) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc58) -// CHECK-NEXT: } loc(#loc58) -// CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc58) -// CHECK-NEXT: %22 = arith.andi %21, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc58) -// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc58) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc58) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc58) -// CHECK-NEXT: } loc(#loc58) -// CHECK-NEXT: %24 = arith.addi %5, %c64_i256 : i256 loc(#loc58) -// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc58) -// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc58) -// CHECK-NEXT: return %22, %26 : i256, i256 loc(#loc59) -// CHECK-NEXT: } loc(#loc52) -// CHECK-NEXT: func.func @roundtrip_addr_payable_191(%arg0: i256 loc({{.*}}:42:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc52) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc52) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc52) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc53) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc54) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc54) +// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc54) +// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc54) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc54) +// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc54) +// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %11 = arith.addi %3, %c64_i256 : i256 loc(#loc54) +// CHECK-NEXT: %12 = arith.cmpi ugt, %11, %c18446744073709551615_i256 : i256 loc(#loc54) +// CHECK-NEXT: %13 = arith.cmpi ult, %11, %3 : i256 loc(#loc54) +// CHECK-NEXT: %14 = arith.ori %12, %13 : i1 loc(#loc54) +// CHECK-NEXT: scf.if %14 { +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %17 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %c65_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: "llvm.intrcall"(%18, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc54) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc54) +// CHECK-NEXT: } loc(#loc54) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: llvm.store %11, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc54) +// CHECK-NEXT: return %3 : i256 loc(#loc55) +// CHECK-NEXT: } loc(#loc51) +// CHECK-NEXT: func.func @roundtrip_addr_183(%arg0: i256 loc({{.*}}:42:24)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc61) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc61) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc61) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc62) -// CHECK-NEXT: %2 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc62) -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc63) -// CHECK-NEXT: %5 = arith.addi %4, %c32_i256 : i256 loc(#loc63) -// CHECK-NEXT: %6 = arith.addi %4, %c64_i256 : i256 loc(#loc63) -// CHECK-NEXT: %7 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %8 = arith.subi %6, %5 : i256 loc(#loc63) -// CHECK-NEXT: %9 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %10 = arith.addi %4, %c64_i256 : i256 loc(#loc63) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc63) -// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc64) -// CHECK-NEXT: %14 = arith.addi %4, %c32_i256 : i256 loc(#loc64) -// CHECK-NEXT: %15 = arith.cmpi slt, %13, %c32_i256 : i256 loc(#loc64) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc64) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc64) -// CHECK-NEXT: } loc(#loc64) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc64) -// CHECK-NEXT: %18 = arith.andi %17, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc64) -// CHECK-NEXT: %19 = arith.cmpi ne, %17, %18 : i256 loc(#loc64) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc64) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc64) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc64) -// CHECK-NEXT: } loc(#loc64) -// CHECK-NEXT: return %18 : i256 loc(#loc65) -// CHECK-NEXT: } loc(#loc60) -// CHECK-NEXT: func.func @encode_contract_210(%arg0: i256 loc({{.*}}:50:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc67) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc67) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc67) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc68) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc69) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc69) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc69) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc69) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc69) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc69) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc69) -// CHECK-NEXT: return %3 : i256 loc(#loc70) -// CHECK-NEXT: } loc(#loc66) -// CHECK-NEXT: func.func @encode_packed_contract_224(%arg0: i256 loc({{.*}}:54:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc57) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc57) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc57) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc58) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc59) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc59) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc59) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc59) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc59) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc59) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc59) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc59) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc59) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc59) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc59) +// CHECK-NEXT: } loc(#loc59) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc59) +// CHECK-NEXT: %15 = arith.addi %3, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %18 = arith.cmpi slt, %17, %c32_i256 : i256 loc(#loc60) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) +// CHECK-NEXT: } loc(#loc60) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc60) +// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc60) +// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc60) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc60) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc60) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc60) +// CHECK-NEXT: } loc(#loc60) +// CHECK-NEXT: return %21 : i256 loc(#loc61) +// CHECK-NEXT: } loc(#loc56) +// CHECK-NEXT: func.func @roundtrip_addr_tuple_209(%arg0: i256 loc({{.*}}:46:30), %arg1: i256 loc({{.*}}:46:41)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc72) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc72) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc72) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc73) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc74) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc74) -// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc74) -// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc74) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc74) -// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc74) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: %11 = arith.addi %3, %c52_i256 : i256 loc(#loc74) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc74) -// CHECK-NEXT: return %3 : i256 loc(#loc75) -// CHECK-NEXT: } loc(#loc71) -// CHECK-NEXT: func.func @decode_contract_240(%arg0: i256 loc({{.*}}:58:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc63) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc63) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc64) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc64) +// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc65) +// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc66) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc67) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc67) +// CHECK-NEXT: %7 = arith.addi %5, %c96_i256 : i256 loc(#loc67) +// CHECK-NEXT: %8 = arith.andi %2, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc67) +// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %10 = arith.addi %5, %c64_i256 : i256 loc(#loc67) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %3, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %12 = arith.subi %7, %6 : i256 loc(#loc67) +// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %12, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %14 = arith.addi %5, %c96_i256 : i256 loc(#loc67) +// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc67) +// CHECK-NEXT: %16 = arith.cmpi ult, %14, %5 : i256 loc(#loc67) +// CHECK-NEXT: %17 = arith.ori %15, %16 : i1 loc(#loc67) +// CHECK-NEXT: scf.if %17 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %c65_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc67) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc67) +// CHECK-NEXT: } loc(#loc67) +// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc67) +// CHECK-NEXT: %19 = arith.addi %5, %c32_i256 : i256 loc(#loc68) +// CHECK-NEXT: %20 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc68) +// CHECK-NEXT: %22 = arith.cmpi slt, %21, %c64_i256 : i256 loc(#loc68) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc68) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc68) +// CHECK-NEXT: } loc(#loc68) +// CHECK-NEXT: %23 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: %24 = llvm.load %23 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc68) +// CHECK-NEXT: %25 = arith.andi %24, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc68) +// CHECK-NEXT: %26 = arith.cmpi ne, %24, %25 : i256 loc(#loc68) +// CHECK-NEXT: scf.if %26 { +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc68) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc68) +// CHECK-NEXT: } loc(#loc68) +// CHECK-NEXT: %27 = arith.addi %5, %c64_i256 : i256 loc(#loc68) +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc68) +// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc68) +// CHECK-NEXT: return %25, %29 : i256, i256 loc(#loc69) +// CHECK-NEXT: } loc(#loc62) +// CHECK-NEXT: func.func @roundtrip_addr_payable_231(%arg0: i256 loc({{.*}}:50:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc71) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc71) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc71) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc72) +// CHECK-NEXT: %2 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc72) +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc73) +// CHECK-NEXT: %5 = arith.addi %4, %c32_i256 : i256 loc(#loc73) +// CHECK-NEXT: %6 = arith.addi %4, %c64_i256 : i256 loc(#loc73) +// CHECK-NEXT: %7 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %8 = arith.subi %6, %5 : i256 loc(#loc73) +// CHECK-NEXT: %9 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %10 = arith.addi %4, %c64_i256 : i256 loc(#loc73) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc73) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %4 : i256 loc(#loc73) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc73) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc73) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc73) +// CHECK-NEXT: } loc(#loc73) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc73) +// CHECK-NEXT: %15 = arith.addi %4, %c32_i256 : i256 loc(#loc74) +// CHECK-NEXT: %16 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc74) +// CHECK-NEXT: %18 = arith.cmpi slt, %17, %c32_i256 : i256 loc(#loc74) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc74) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc74) +// CHECK-NEXT: } loc(#loc74) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc74) +// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc74) +// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc74) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc74) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc74) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc74) +// CHECK-NEXT: } loc(#loc74) +// CHECK-NEXT: return %21 : i256 loc(#loc75) +// CHECK-NEXT: } loc(#loc70) +// CHECK-NEXT: func.func @encode_contract_250(%arg0: i256 loc({{.*}}:58:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc77) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc77) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc77) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc78) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc79) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc79) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc79) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc79) -// CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc79) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc79) -// CHECK-NEXT: } loc(#loc79) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc79) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc79) -// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc79) -// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc79) -// CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) -// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc79) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc79) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc79) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc79) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc79) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc79) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc79) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc79) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc79) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc79) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc79) // CHECK-NEXT: } loc(#loc79) -// CHECK-NEXT: return %8 : i256 loc(#loc80) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc79) +// CHECK-NEXT: return %3 : i256 loc(#loc80) // CHECK-NEXT: } loc(#loc76) -// CHECK-NEXT: func.func @roundtrip_contract_260(%arg0: i256 loc({{.*}}:62:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_contract_264(%arg0: i256 loc({{.*}}:62:32)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c52_i256 = arith.constant 52 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -2634,221 +3934,217 @@ contract StorageBytes { // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc84) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc84) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc84) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc84) -// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc84) +// CHECK-NEXT: %5 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc84) +// CHECK-NEXT: %6 = arith.shli %5, %c96_i256 : i256 loc(#loc84) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc84) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc84) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc84) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) -// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc85) -// CHECK-NEXT: %14 = arith.addi %3, %c32_i256 : i256 loc(#loc85) -// CHECK-NEXT: %15 = arith.cmpi slt, %13, %c32_i256 : i256 loc(#loc85) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc85) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc85) -// CHECK-NEXT: } loc(#loc85) -// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc85) -// CHECK-NEXT: %18 = arith.andi %17, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc85) -// CHECK-NEXT: %19 = arith.cmpi ne, %17, %18 : i256 loc(#loc85) -// CHECK-NEXT: scf.if %19 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc85) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc85) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc85) -// CHECK-NEXT: } loc(#loc85) -// CHECK-NEXT: return %18 : i256 loc(#loc86) +// CHECK-NEXT: %8 = arith.addi %3, %c52_i256 : i256 loc(#loc84) +// CHECK-NEXT: %9 = arith.subi %8, %4 : i256 loc(#loc84) +// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: %11 = arith.addi %3, %c64_i256 : i256 loc(#loc84) +// CHECK-NEXT: %12 = arith.cmpi ugt, %11, %c18446744073709551615_i256 : i256 loc(#loc84) +// CHECK-NEXT: %13 = arith.cmpi ult, %11, %3 : i256 loc(#loc84) +// CHECK-NEXT: %14 = arith.ori %12, %13 : i1 loc(#loc84) +// CHECK-NEXT: scf.if %14 { +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: %17 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %c65_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: "llvm.intrcall"(%18, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc84) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc84) +// CHECK-NEXT: } loc(#loc84) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: llvm.store %11, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc84) +// CHECK-NEXT: return %3 : i256 loc(#loc85) // CHECK-NEXT: } loc(#loc81) -// CHECK-NEXT: func.func @decode_contract_tuple_280(%arg0: i256 loc({{.*}}:66:31)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @decode_contract_280(%arg0: i256 loc({{.*}}:66:25)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc88) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc88) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc88) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc89) -// CHECK-NEXT: %2 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc90) -// CHECK-NEXT: %4 = arith.addi %1, %c32_i256 : i256 loc(#loc90) -// CHECK-NEXT: %5 = arith.cmpi slt, %3, %c64_i256 : i256 loc(#loc90) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc87) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc87) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc87) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc88) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc89) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc89) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c32_i256 : i256 loc(#loc89) // CHECK-NEXT: scf.if %5 { -// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc90) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc90) -// CHECK-NEXT: } loc(#loc90) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc90) -// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc90) -// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc90) +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc89) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc89) +// CHECK-NEXT: } loc(#loc89) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc89) +// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc89) +// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc89) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc90) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc90) -// CHECK-NEXT: } loc(#loc90) -// CHECK-NEXT: %10 = arith.addi %1, %c64_i256 : i256 loc(#loc90) -// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc90) -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc90) -// CHECK-NEXT: return %8, %12 : i256, i256 loc(#loc91) -// CHECK-NEXT: } loc(#loc87) -// CHECK-NEXT: func.func @encode_packed_array_signed_298(%arg0: i256 loc({{.*}}:72:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) -// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc93) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc93) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc93) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc94) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc95) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc95) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc95) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc95) -// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc95) -// CHECK-NEXT: %16 = arith.extsi %15 : i8 to i256 loc(#loc95) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc95) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc95) -// CHECK-NEXT: } loc(#loc95) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc95) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc95) -// CHECK-NEXT: return %3 : i256 loc(#loc96) -// CHECK-NEXT: } loc(#loc92) -// CHECK-NEXT: func.func @encode_packed_array_unsigned_312(%arg0: i256 loc({{.*}}:76:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc89) +// CHECK-NEXT: "llvm.intrcall"(%10, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc89) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc89) +// CHECK-NEXT: } loc(#loc89) +// CHECK-NEXT: return %8 : i256 loc(#loc90) +// CHECK-NEXT: } loc(#loc86) +// CHECK-NEXT: func.func @decode_contract_calldata_296(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:70:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) -// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc98) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc98) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc98) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc99) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc100) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) -// CHECK-NEXT: %15 = arith.trunci %14 : i256 to i8 loc(#loc100) -// CHECK-NEXT: %16 = arith.extui %15 : i8 to i256 loc(#loc100) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc100) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc100) -// CHECK-NEXT: } loc(#loc100) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc100) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc100) -// CHECK-NEXT: return %3 : i256 loc(#loc101) -// CHECK-NEXT: } loc(#loc97) -// CHECK-NEXT: func.func @encode_packed_array_enum_327(%arg0: i256 loc({{.*}}:80:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc92) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc92) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc92) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc93) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc94) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc94) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c32_i256 : i256 loc(#loc94) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc94) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc94) +// CHECK-NEXT: } loc(#loc94) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc94) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc94) +// CHECK-NEXT: %7 = arith.andi %6, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc94) +// CHECK-NEXT: %8 = arith.cmpi ne, %6, %7 : i256 loc(#loc94) +// CHECK-NEXT: scf.if %8 { +// CHECK-NEXT: %9 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc94) +// CHECK-NEXT: "llvm.intrcall"(%9, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc94) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc94) +// CHECK-NEXT: } loc(#loc94) +// CHECK-NEXT: return %7 : i256 loc(#loc95) +// CHECK-NEXT: } loc(#loc91) +// CHECK-NEXT: func.func @roundtrip_contract_316(%arg0: i256 loc({{.*}}:74:28)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc97) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc97) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc97) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc98) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc99) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc99) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc99) +// CHECK-NEXT: %6 = arith.andi %1, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc99) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc99) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc99) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc99) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc99) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc99) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %24 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %c65_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: "llvm.intrcall"(%25, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc99) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc99) +// CHECK-NEXT: } loc(#loc99) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc99) +// CHECK-NEXT: %15 = arith.addi %3, %c32_i256 : i256 loc(#loc100) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) +// CHECK-NEXT: %18 = arith.cmpi slt, %17, %c32_i256 : i256 loc(#loc100) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc100) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc100) +// CHECK-NEXT: } loc(#loc100) +// CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc100) +// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc100) +// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc100) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc100) +// CHECK-NEXT: "llvm.intrcall"(%23, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc100) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc100) +// CHECK-NEXT: } loc(#loc100) +// CHECK-NEXT: return %21 : i256 loc(#loc101) +// CHECK-NEXT: } loc(#loc96) +// CHECK-NEXT: func.func @decode_contract_tuple_336(%arg0: i256 loc({{.*}}:78:31)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc103) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc103) // CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc103) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc104) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc105) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) -// CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c2_i256 : i256 loc(#loc105) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %c33_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc105) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc105) -// CHECK-NEXT: } loc(#loc105) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc105) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc105) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc105) +// CHECK-NEXT: %3 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) +// CHECK-NEXT: %5 = arith.cmpi slt, %4, %c64_i256 : i256 loc(#loc105) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc105) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc105) // CHECK-NEXT: } loc(#loc105) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc105) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc105) -// CHECK-NEXT: return %3 : i256 loc(#loc106) +// CHECK-NEXT: %6 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) +// CHECK-NEXT: %8 = arith.andi %7, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc105) +// CHECK-NEXT: %9 = arith.cmpi ne, %7, %8 : i256 loc(#loc105) +// CHECK-NEXT: scf.if %9 { +// CHECK-NEXT: %13 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: "llvm.intrcall"(%13, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc105) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc105) +// CHECK-NEXT: } loc(#loc105) +// CHECK-NEXT: %10 = arith.addi %1, %c64_i256 : i256 loc(#loc105) +// CHECK-NEXT: %11 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc105) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc105) +// CHECK-NEXT: return %8, %12 : i256, i256 loc(#loc106) // CHECK-NEXT: } loc(#loc102) -// CHECK-NEXT: func.func @encode_packed_array_bool_341(%arg0: i256 loc({{.*}}:84:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: func.func @decode_contract_tuple_calldata_356(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:82:40)) -> (i256, i256) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc108) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc108) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc108) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc109) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc110) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc110) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc110) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc110) -// CHECK-NEXT: %15 = arith.cmpi ne, %14, %c0_i256 : i256 loc(#loc110) -// CHECK-NEXT: %16 = arith.extui %15 : i1 to i256 loc(#loc110) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc110) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc110) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc108) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc108) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc109) +// CHECK-NEXT: %2 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc110) +// CHECK-NEXT: %3 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc110) +// CHECK-NEXT: %4 = arith.cmpi slt, %3, %c64_i256 : i256 loc(#loc110) +// CHECK-NEXT: scf.if %4 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc110) +// CHECK-NEXT: "llvm.intrcall"(%12, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc110) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc110) // CHECK-NEXT: } loc(#loc110) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc110) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc110) -// CHECK-NEXT: return %3 : i256 loc(#loc111) +// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<2> loc(#loc110) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc110) +// CHECK-NEXT: %7 = arith.andi %6, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc110) +// CHECK-NEXT: %8 = arith.cmpi ne, %6, %7 : i256 loc(#loc110) +// CHECK-NEXT: scf.if %8 { +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc110) +// CHECK-NEXT: "llvm.intrcall"(%12, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc110) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc110) +// CHECK-NEXT: } loc(#loc110) +// CHECK-NEXT: %9 = arith.addi %2, %c32_i256 : i256 loc(#loc110) +// CHECK-NEXT: %10 = llvm.inttoptr %9 : i256 to !llvm.ptr<2> loc(#loc110) +// CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc110) +// CHECK-NEXT: return %7, %11 : i256, i256 loc(#loc111) // CHECK-NEXT: } loc(#loc107) -// CHECK-NEXT: func.func @encode_packed_array_address_355(%arg0: i256 loc({{.*}}:88:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_array_signed_374(%arg0: i256 loc({{.*}}:88:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -2864,25 +4160,50 @@ contract StorageBytes { // CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc115) // CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc115) // CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc115) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc115) -// CHECK-NEXT: %15 = arith.andi %14, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc115) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc115) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc115) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc115) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc115) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc115) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc115) +// CHECK-NEXT: %23 = arith.trunci %22 : i256 to i8 loc(#loc115) +// CHECK-NEXT: %24 = arith.extsi %23 : i8 to i256 loc(#loc115) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc115) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc115) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc115) // CHECK-NEXT: } loc(#loc115) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc115) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc115) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc115) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc115) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc115) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc115) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc115) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc115) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc115) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc115) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc115) +// CHECK-NEXT: } loc(#loc115) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc115) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc115) // CHECK-NEXT: return %3 : i256 loc(#loc116) // CHECK-NEXT: } loc(#loc112) -// CHECK-NEXT: func.func @encode_packed_contract_address_370(%arg0: i256 loc({{.*}}:92:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_array_unsigned_388(%arg0: i256 loc({{.*}}:92:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -2898,185 +4219,296 @@ contract StorageBytes { // CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc120) // CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc120) // CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc120) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc120) -// CHECK-NEXT: %15 = arith.andi %14, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc120) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc120) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc120) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc120) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc120) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc120) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc120) +// CHECK-NEXT: %23 = arith.trunci %22 : i256 to i8 loc(#loc120) +// CHECK-NEXT: %24 = arith.extui %23 : i8 to i256 loc(#loc120) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc120) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc120) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc120) +// CHECK-NEXT: } loc(#loc120) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc120) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc120) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc120) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc120) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc120) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc120) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc120) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc120) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc120) // CHECK-NEXT: } loc(#loc120) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc120) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc120) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc120) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc120) // CHECK-NEXT: return %3 : i256 loc(#loc121) // CHECK-NEXT: } loc(#loc117) -// CHECK-NEXT: func.func @encode_packed_calldata_array_signed_384(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:96:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_array_enum_403(%arg0: i256 loc({{.*}}:96:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc123) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc123) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc123) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc124) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc123) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc123) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc124) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc125) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc125) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc125) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc125) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc125) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc125) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc125) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc125) -// CHECK-NEXT: %14 = arith.trunci %13 : i256 to i8 loc(#loc125) -// CHECK-NEXT: %15 = arith.extsi %14 : i8 to i256 loc(#loc125) -// CHECK-NEXT: %16 = arith.cmpi ne, %13, %15 : i256 loc(#loc125) -// CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc125) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc125) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc125) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc125) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc125) +// CHECK-NEXT: %23 = arith.cmpi ugt, %22, %c2_i256 : i256 loc(#loc125) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %28 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c33_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: "llvm.intrcall"(%29, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc125) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc125) // CHECK-NEXT: } loc(#loc125) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: llvm.store %15, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc125) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc125) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc125) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc125) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc125) // CHECK-NEXT: } loc(#loc125) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc125) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc125) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc125) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc125) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc125) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc125) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc125) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc125) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc125) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc125) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc125) +// CHECK-NEXT: } loc(#loc125) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc125) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc125) // CHECK-NEXT: return %3 : i256 loc(#loc126) // CHECK-NEXT: } loc(#loc122) -// CHECK-NEXT: func.func @encode_packed_calldata_array_unsigned_398(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:100:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_array_bool_417(%arg0: i256 loc({{.*}}:100:34)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc128) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc128) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc128) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc129) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc128) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc128) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc129) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc130) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc130) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc130) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc130) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc130) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc130) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc130) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc130) -// CHECK-NEXT: %14 = arith.trunci %13 : i256 to i8 loc(#loc130) -// CHECK-NEXT: %15 = arith.extui %14 : i8 to i256 loc(#loc130) -// CHECK-NEXT: %16 = arith.cmpi ne, %13, %15 : i256 loc(#loc130) -// CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc130) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc130) -// CHECK-NEXT: } loc(#loc130) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: llvm.store %15, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc130) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc130) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc130) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc130) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc130) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc130) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc130) +// CHECK-NEXT: %23 = arith.cmpi ne, %22, %c0_i256 : i256 loc(#loc130) +// CHECK-NEXT: %24 = arith.extui %23 : i1 to i256 loc(#loc130) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %24, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc130) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc130) +// CHECK-NEXT: } loc(#loc130) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc130) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc130) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc130) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc130) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc130) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc130) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc130) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc130) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc130) // CHECK-NEXT: } loc(#loc130) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc130) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc130) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc130) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc130) // CHECK-NEXT: return %3 : i256 loc(#loc131) // CHECK-NEXT: } loc(#loc127) -// CHECK-NEXT: func.func @encode_packed_calldata_array_enum_413(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:104:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_array_address_431(%arg0: i256 loc({{.*}}:104:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc133) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc133) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc133) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc134) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc133) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc133) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc134) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc135) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc135) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc135) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc135) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc135) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc135) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc135) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc135) -// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c2_i256 : i256 loc(#loc135) -// CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: "llvm.intrcall"(%18, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc135) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc135) -// CHECK-NEXT: } loc(#loc135) -// CHECK-NEXT: %15 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: llvm.store %13, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: %16 = arith.addi %arg2, %c32_i256 : i256 loc(#loc135) -// CHECK-NEXT: %17 = arith.addi %arg3, %c32_i256 : i256 loc(#loc135) -// CHECK-NEXT: scf.yield %16, %17 : i256, i256 loc(#loc135) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc135) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc135) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc135) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc135) +// CHECK-NEXT: %23 = arith.andi %22, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc135) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc135) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc135) +// CHECK-NEXT: } loc(#loc135) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc135) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc135) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc135) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc135) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc135) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc135) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc135) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc135) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc135) // CHECK-NEXT: } loc(#loc135) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc135) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc135) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc135) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc135) // CHECK-NEXT: return %3 : i256 loc(#loc136) // CHECK-NEXT: } loc(#loc132) -// CHECK-NEXT: func.func @encode_packed_calldata_array_bool_427(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:108:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_contract_address_446(%arg0: i256 loc({{.*}}:108:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc138) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc138) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc138) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc139) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc138) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc138) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc139) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc140) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc140) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc140) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc140) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc140) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc140) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc140) -// CHECK-NEXT: %14 = arith.cmpi ne, %13, %c0_i256 : i256 loc(#loc140) -// CHECK-NEXT: %15 = arith.extui %14 : i1 to i256 loc(#loc140) -// CHECK-NEXT: %16 = arith.cmpi ne, %13, %15 : i256 loc(#loc140) -// CHECK-NEXT: scf.if %16 { -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: "llvm.intrcall"(%20, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc140) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc140) -// CHECK-NEXT: } loc(#loc140) -// CHECK-NEXT: %17 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: llvm.store %15, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: %18 = arith.addi %arg2, %c32_i256 : i256 loc(#loc140) -// CHECK-NEXT: %19 = arith.addi %arg3, %c32_i256 : i256 loc(#loc140) -// CHECK-NEXT: scf.yield %18, %19 : i256, i256 loc(#loc140) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc140) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc140) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc140) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc140) +// CHECK-NEXT: %23 = arith.andi %22, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc140) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc140) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc140) // CHECK-NEXT: } loc(#loc140) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc140) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc140) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc140) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc140) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc140) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc140) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc140) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc140) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc140) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc140) +// CHECK-NEXT: } loc(#loc140) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc140) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc140) // CHECK-NEXT: return %3 : i256 loc(#loc141) // CHECK-NEXT: } loc(#loc137) -// CHECK-NEXT: func.func @encode_packed_calldata_array_address_441(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:112:46)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_signed_460(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:112:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -3091,32 +4523,56 @@ contract StorageBytes { // CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc145) // CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc145) // CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc145) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc145) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc145) -// CHECK-NEXT: %14 = arith.andi %13, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc145) -// CHECK-NEXT: %15 = arith.cmpi ne, %13, %14 : i256 loc(#loc145) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc145) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc145) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc145) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc145) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc145) +// CHECK-NEXT: %22 = arith.trunci %21 : i256 to i8 loc(#loc145) +// CHECK-NEXT: %23 = arith.extsi %22 : i8 to i256 loc(#loc145) +// CHECK-NEXT: %24 = arith.cmpi ne, %21, %23 : i256 loc(#loc145) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc145) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc145) // CHECK-NEXT: } loc(#loc145) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc145) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc145) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc145) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %23, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc145) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc145) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc145) // CHECK-NEXT: } loc(#loc145) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc145) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc145) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc145) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc145) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc145) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc145) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc145) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc145) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc145) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc145) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc145) +// CHECK-NEXT: } loc(#loc145) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc145) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc145) // CHECK-NEXT: return %3 : i256 loc(#loc146) // CHECK-NEXT: } loc(#loc142) -// CHECK-NEXT: func.func @encode_packed_calldata_array_contract_456(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:116:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_unsigned_474(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:116:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -3131,356 +4587,484 @@ contract StorageBytes { // CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc150) // CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc150) // CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc150) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc150) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc150) -// CHECK-NEXT: %14 = arith.andi %13, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc150) -// CHECK-NEXT: %15 = arith.cmpi ne, %13, %14 : i256 loc(#loc150) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc150) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc150) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc150) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc150) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc150) +// CHECK-NEXT: %22 = arith.trunci %21 : i256 to i8 loc(#loc150) +// CHECK-NEXT: %23 = arith.extui %22 : i8 to i256 loc(#loc150) +// CHECK-NEXT: %24 = arith.cmpi ne, %21, %23 : i256 loc(#loc150) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc150) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc150) // CHECK-NEXT: } loc(#loc150) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc150) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc150) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc150) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %23, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc150) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc150) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc150) +// CHECK-NEXT: } loc(#loc150) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc150) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc150) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc150) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc150) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc150) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc150) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc150) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc150) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc150) // CHECK-NEXT: } loc(#loc150) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc150) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc150) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc150) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc150) // CHECK-NEXT: return %3 : i256 loc(#loc151) // CHECK-NEXT: } loc(#loc147) -// CHECK-NEXT: func.func @encode_bool_469(%arg0: i1 loc({{.*}}:120:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_enum_489(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:120:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc153) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc153) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc153) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc154) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc153) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc153) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc154) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc155) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc155) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc155) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc155) -// CHECK-NEXT: %6 = arith.extui %1 : i1 to i256 loc(#loc155) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc155) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc155) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc155) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc155) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc155) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc155) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc155) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc155) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc155) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc155) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c2_i256 : i256 loc(#loc155) +// CHECK-NEXT: scf.if %22 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc155) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc155) +// CHECK-NEXT: } loc(#loc155) +// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc155) +// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc155) +// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc155) +// CHECK-NEXT: } loc(#loc155) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc155) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc155) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc155) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc155) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc155) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc155) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc155) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc155) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc155) +// CHECK-NEXT: } loc(#loc155) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc155) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc155) // CHECK-NEXT: return %3 : i256 loc(#loc156) // CHECK-NEXT: } loc(#loc152) -// CHECK-NEXT: func.func @encode_uint8_482(%arg0: i8 loc({{.*}}:124:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_bool_503(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:124:43)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc158) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i8 : (i256) -> !llvm.ptr loc(#loc158) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i8, !llvm.ptr loc(#loc158) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i8 loc(#loc159) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc158) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc158) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc159) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc160) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc160) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc160) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc160) -// CHECK-NEXT: %6 = arith.extui %1 : i8 to i256 loc(#loc160) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc160) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc160) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc160) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc160) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc160) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc160) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc160) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc160) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc160) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc160) +// CHECK-NEXT: %22 = arith.cmpi ne, %21, %c0_i256 : i256 loc(#loc160) +// CHECK-NEXT: %23 = arith.extui %22 : i1 to i256 loc(#loc160) +// CHECK-NEXT: %24 = arith.cmpi ne, %21, %23 : i256 loc(#loc160) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc160) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc160) +// CHECK-NEXT: } loc(#loc160) +// CHECK-NEXT: %25 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %23, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %26 = arith.addi %arg2, %c32_i256 : i256 loc(#loc160) +// CHECK-NEXT: %27 = arith.addi %arg3, %c32_i256 : i256 loc(#loc160) +// CHECK-NEXT: scf.yield %26, %27 : i256, i256 loc(#loc160) +// CHECK-NEXT: } loc(#loc160) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc160) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc160) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc160) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc160) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc160) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc160) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc160) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc160) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc160) +// CHECK-NEXT: } loc(#loc160) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc160) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc160) // CHECK-NEXT: return %3 : i256 loc(#loc161) // CHECK-NEXT: } loc(#loc157) -// CHECK-NEXT: func.func @encode_enum_496(%arg0: i256 loc({{.*}}:128:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_packed_calldata_array_address_517(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:128:46)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) -// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc163) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc163) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc163) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc164) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc163) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc163) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc164) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc165) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc165) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc165) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc165) -// CHECK-NEXT: %6 = arith.cmpi ugt, %1, %c2_i256 : i256 loc(#loc165) -// CHECK-NEXT: scf.if %6 { -// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %c33_i256, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: "llvm.intrcall"(%14, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc165) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc165) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc165) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc165) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc165) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc165) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc165) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc165) +// CHECK-NEXT: %22 = arith.andi %21, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc165) +// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc165) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc165) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc165) +// CHECK-NEXT: } loc(#loc165) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc165) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc165) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc165) +// CHECK-NEXT: } loc(#loc165) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc165) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc165) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc165) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc165) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc165) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc165) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc165) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc165) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc165) // CHECK-NEXT: } loc(#loc165) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %1, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc165) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc165) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc165) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc165) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc165) // CHECK-NEXT: return %3 : i256 loc(#loc166) // CHECK-NEXT: } loc(#loc162) -// CHECK-NEXT: func.func @encode_bytes5_509(%arg0: i256 loc({{.*}}:132:23)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_packed_calldata_array_contract_532(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:132:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc168) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc168) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc168) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc169) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc168) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc168) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc169) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc170) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc170) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc170) -// CHECK-NEXT: %6 = arith.andi %1, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc170) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc170) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc170) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc170) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc170) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc170) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc170) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc170) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc170) +// CHECK-NEXT: %22 = arith.andi %21, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc170) +// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc170) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc170) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc170) +// CHECK-NEXT: } loc(#loc170) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc170) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc170) +// CHECK-NEXT: } loc(#loc170) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc170) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc170) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc170) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc170) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc170) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc170) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc170) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc170) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc170) +// CHECK-NEXT: } loc(#loc170) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc170) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc170) // CHECK-NEXT: return %3 : i256 loc(#loc171) // CHECK-NEXT: } loc(#loc167) -// CHECK-NEXT: func.func @encode_array_calldata_unsigned_523(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:136:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_bool_545(%arg0: i1 loc({{.*}}:136:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc173) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc173) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc173) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc174) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i1 : (i256) -> !llvm.ptr loc(#loc173) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i1, !llvm.ptr loc(#loc173) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc174) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc175) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc175) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc175) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc175) +// CHECK-NEXT: %6 = arith.extui %1 : i1 to i256 loc(#loc175) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc175) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc175) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc175) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc175) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc175) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc175) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc175) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc175) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc175) -// CHECK-NEXT: %21 = arith.trunci %20 : i256 to i8 loc(#loc175) -// CHECK-NEXT: %22 = arith.extui %21 : i8 to i256 loc(#loc175) -// CHECK-NEXT: %23 = arith.cmpi ne, %20, %22 : i256 loc(#loc175) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc175) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc175) -// CHECK-NEXT: } loc(#loc175) -// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc175) -// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc175) -// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc175) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc175) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc175) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc175) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc175) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc175) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc175) // CHECK-NEXT: } loc(#loc175) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc175) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc175) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc175) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc175) // CHECK-NEXT: return %3 : i256 loc(#loc176) // CHECK-NEXT: } loc(#loc172) -// CHECK-NEXT: func.func @encode_array_calldata_nested_unsigned_538(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:140:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_uint8_558(%arg0: i8 loc({{.*}}:140:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc178) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc178) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc178) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc179) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i8 : (i256) -> !llvm.ptr loc(#loc178) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i8, !llvm.ptr loc(#loc178) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i8 loc(#loc179) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc180) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc180) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc180) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc180) +// CHECK-NEXT: %6 = arith.extui %1 : i8 to i256 loc(#loc180) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc180) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc180) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc180) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc180) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc180) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc180) -// CHECK-NEXT: %15:3 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12, %arg4 = %14) -> (i256, i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc180) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc180) -// CHECK-NEXT: %21 = arith.addi %12, %20 : i256 loc(#loc180) -// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<2> loc(#loc180) -// CHECK-NEXT: %23 = llvm.load %22 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc180) -// CHECK-NEXT: %24 = arith.addi %21, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %25 = arith.subi %arg4, %11 : i256 loc(#loc180) -// CHECK-NEXT: %26 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %27 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %28 = arith.index_castui %23 : i256 to index loc(#loc180) -// CHECK-NEXT: %29 = arith.addi %arg4, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %30 = arith.muli %23, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %31 = arith.addi %29, %30 : i256 loc(#loc180) -// CHECK-NEXT: %32:2 = scf.for %arg5 = %c0 to %28 step %c1 iter_args(%arg6 = %29, %arg7 = %24) -> (i256, i256) { -// CHECK-NEXT: %35 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<2> loc(#loc180) -// CHECK-NEXT: %36 = llvm.load %35 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc180) -// CHECK-NEXT: %37 = arith.trunci %36 : i256 to i8 loc(#loc180) -// CHECK-NEXT: %38 = arith.extui %37 : i8 to i256 loc(#loc180) -// CHECK-NEXT: %39 = arith.cmpi ne, %36, %38 : i256 loc(#loc180) -// CHECK-NEXT: scf.if %39 { -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: "llvm.intrcall"(%43, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc180) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc180) -// CHECK-NEXT: } loc(#loc180) -// CHECK-NEXT: %40 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %38, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %41 = arith.addi %arg6, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %42 = arith.addi %arg7, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: scf.yield %41, %42 : i256, i256 loc(#loc180) -// CHECK-NEXT: } loc(#loc180) -// CHECK-NEXT: %33 = arith.addi %arg2, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: %34 = arith.addi %arg3, %c32_i256 : i256 loc(#loc180) -// CHECK-NEXT: scf.yield %33, %34, %31 : i256, i256, i256 loc(#loc180) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc180) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc180) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc180) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc180) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc180) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc180) // CHECK-NEXT: } loc(#loc180) -// CHECK-NEXT: %16 = arith.subi %15#2, %4 : i256 loc(#loc180) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc180) -// CHECK-NEXT: llvm.store %15#2, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc180) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc180) // CHECK-NEXT: return %3 : i256 loc(#loc181) // CHECK-NEXT: } loc(#loc177) -// CHECK-NEXT: func.func @encode_array_calldata_bool_552(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:144:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_enum_572(%arg0: i256 loc({{.*}}:144:21)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc183) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc183) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc183) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc184) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc183) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc183) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc184) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc185) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc185) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc185) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc185) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc185) +// CHECK-NEXT: %6 = arith.cmpi ugt, %1, %c2_i256 : i256 loc(#loc185) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c33_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc185) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc185) +// CHECK-NEXT: } loc(#loc185) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc185) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %1, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc185) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc185) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc185) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc185) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc185) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc185) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc185) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc185) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc185) -// CHECK-NEXT: %21 = arith.cmpi ne, %20, %c0_i256 : i256 loc(#loc185) -// CHECK-NEXT: %22 = arith.extui %21 : i1 to i256 loc(#loc185) -// CHECK-NEXT: %23 = arith.cmpi ne, %20, %22 : i256 loc(#loc185) -// CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc185) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc185) -// CHECK-NEXT: } loc(#loc185) -// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc185) -// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc185) -// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc185) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc185) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc185) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc185) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc185) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc185) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc185) // CHECK-NEXT: } loc(#loc185) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc185) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc185) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc185) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc185) // CHECK-NEXT: return %3 : i256 loc(#loc186) // CHECK-NEXT: } loc(#loc182) -// CHECK-NEXT: func.func @encode_array_calldata_enum_567(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:148:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: func.func @encode_bytes5_585(%arg0: i256 loc({{.*}}:148:23)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) -// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc188) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc188) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc188) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc189) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc188) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc188) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc189) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc190) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc190) // CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc190) -// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc190) +// CHECK-NEXT: %6 = arith.andi %1, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc190) // CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc190) -// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc190) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc190) -// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc190) -// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc190) -// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc190) -// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc190) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc190) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc190) -// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c2_i256 : i256 loc(#loc190) -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: "llvm.intrcall"(%25, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc190) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc190) -// CHECK-NEXT: } loc(#loc190) -// CHECK-NEXT: %22 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: llvm.store %20, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %23 = arith.addi %arg2, %c32_i256 : i256 loc(#loc190) -// CHECK-NEXT: %24 = arith.addi %arg3, %c32_i256 : i256 loc(#loc190) -// CHECK-NEXT: scf.yield %23, %24 : i256, i256 loc(#loc190) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc190) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc190) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc190) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc190) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc190) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc190) // CHECK-NEXT: } loc(#loc190) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc190) -// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc190) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc190) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc190) // CHECK-NEXT: return %3 : i256 loc(#loc191) // CHECK-NEXT: } loc(#loc187) -// CHECK-NEXT: func.func @encode_array_calldata_address_581(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:152:39)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_unsigned_599(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:152:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -3505,32 +5089,62 @@ contract StorageBytes { // CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc195) // CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc195) // CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc195) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc195) -// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc195) -// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc195) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc195) +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc195) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc195) +// CHECK-NEXT: %28 = arith.trunci %27 : i256 to i8 loc(#loc195) +// CHECK-NEXT: %29 = arith.extui %28 : i8 to i256 loc(#loc195) +// CHECK-NEXT: %30 = arith.cmpi ne, %27, %29 : i256 loc(#loc195) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc195) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc195) // CHECK-NEXT: } loc(#loc195) -// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc195) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc195) -// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc195) +// CHECK-NEXT: %31 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %29, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %32 = arith.addi %arg2, %c32_i256 : i256 loc(#loc195) +// CHECK-NEXT: %33 = arith.addi %arg3, %c32_i256 : i256 loc(#loc195) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc195) // CHECK-NEXT: } loc(#loc195) // CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc195) // CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc195) // CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc195) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc195) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc195) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc195) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc195) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc195) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc195) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc195) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc195) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc195) +// CHECK-NEXT: } loc(#loc195) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc195) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc195) // CHECK-NEXT: return %3 : i256 loc(#loc196) // CHECK-NEXT: } loc(#loc192) -// CHECK-NEXT: func.func @encode_array_calldata_contract_596(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:156:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_nested_unsigned_614(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:156:47)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) +// CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099523263123094306816 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099014633433810337792 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256 = arith.constant 33214008156304899519588147313201233507092696561447677201099231078946096545792 : i256 loc(#loc) +// CHECK-NEXT: %c30_i256 = arith.constant 30 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256 = arith.constant 3963877391197344453575983046348115674221700746820753546331534351508065746944 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -3554,73 +5168,188 @@ contract StorageBytes { // CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc200) // CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc200) // CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc200) -// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc200) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) -// CHECK-NEXT: %21 = arith.andi %20, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc200) -// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc200) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: %15:3 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12, %arg4 = %14) -> (i256, i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc200) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) +// CHECK-NEXT: %28 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc200) +// CHECK-NEXT: %29 = arith.subi %28, %12 : i256 loc(#loc200) +// CHECK-NEXT: %30 = arith.subi %29, %c31_i256 : i256 loc(#loc200) +// CHECK-NEXT: %31 = arith.cmpi sge, %27, %30 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %31 { +// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc200) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc200) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c30_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc200) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099231078946096545792_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %60 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%60, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %32 = arith.addi %12, %27 : i256 loc(#loc200) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<2> loc(#loc200) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) +// CHECK-NEXT: %35 = arith.addi %32, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %36 = arith.cmpi ugt, %34, %c18446744073709551615_i256 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %36 { +// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc200) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc200) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c30_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc200) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099014633433810337792_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %60 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%60, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) // CHECK-NEXT: } loc(#loc200) -// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc200) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc200) -// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc200) +// CHECK-NEXT: %37 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc200) +// CHECK-NEXT: %38 = arith.muli %34, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %39 = arith.subi %37, %38 : i256 loc(#loc200) +// CHECK-NEXT: %40 = arith.cmpi sgt, %35, %39 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %40 { +// CHECK-NEXT: %51 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %54 = arith.addi %52, %c4_i256 : i256 loc(#loc200) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c32_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %56 = arith.addi %52, %c36_i256 : i256 loc(#loc200) +// CHECK-NEXT: %57 = llvm.inttoptr %56 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c30_i256, %57 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %52, %c68_i256 : i256 loc(#loc200) +// CHECK-NEXT: %59 = llvm.inttoptr %58 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c33214008156304899519588147313201233507092696561447677201099523263123094306816_i256, %59 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %60 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%60, %c100_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %41 = arith.subi %arg4, %11 : i256 loc(#loc200) +// CHECK-NEXT: %42 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %41, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %43 = llvm.inttoptr %arg4 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %34, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %44 = arith.index_castui %34 : i256 to index loc(#loc200) +// CHECK-NEXT: %45 = arith.addi %arg4, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %46 = arith.muli %34, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %47 = arith.addi %45, %46 : i256 loc(#loc200) +// CHECK-NEXT: %48:2 = scf.for %arg5 = %c0 to %44 step %c1 iter_args(%arg6 = %45, %arg7 = %35) -> (i256, i256) { +// CHECK-NEXT: %51 = llvm.inttoptr %arg7 : i256 to !llvm.ptr<2> loc(#loc200) +// CHECK-NEXT: %52 = llvm.load %51 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc200) +// CHECK-NEXT: %53 = arith.trunci %52 : i256 to i8 loc(#loc200) +// CHECK-NEXT: %54 = arith.extui %53 : i8 to i256 loc(#loc200) +// CHECK-NEXT: %55 = arith.cmpi ne, %52, %54 : i256 loc(#loc200) +// CHECK-NEXT: scf.if %55 { +// CHECK-NEXT: %59 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%59, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %56 = llvm.inttoptr %arg6 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %54, %56 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %57 = arith.addi %arg6, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %58 = arith.addi %arg7, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: scf.yield %57, %58 : i256, i256 loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %49 = arith.addi %arg2, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %50 = arith.addi %arg3, %c32_i256 : i256 loc(#loc200) +// CHECK-NEXT: scf.yield %49, %50, %47 : i256, i256, i256 loc(#loc200) // CHECK-NEXT: } loc(#loc200) -// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc200) +// CHECK-NEXT: %16 = arith.subi %15#2, %4 : i256 loc(#loc200) // CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc200) // CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %18 = arith.subi %15#2, %3 : i256 loc(#loc200) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc200) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc200) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc200) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc200) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc200) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc200) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc200) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc200) +// CHECK-NEXT: } loc(#loc200) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc200) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc200) // CHECK-NEXT: return %3 : i256 loc(#loc201) // CHECK-NEXT: } loc(#loc197) -// CHECK-NEXT: func.func @encode_packed_calldata_array_bytes5_610(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:160:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @enc_nested_631(%arg0: i256 loc({{.*}}:160:20)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c3 = arith.constant 3 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc203) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc203) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc203) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc204) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc203) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc203) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc204) // CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc205) // CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc205) // CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc205) -// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc205) -// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc205) -// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc205) -// CHECK-NEXT: %8:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { -// CHECK-NEXT: %12 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc205) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc205) -// CHECK-NEXT: %14 = arith.andi %13, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc205) -// CHECK-NEXT: %15 = arith.cmpi ne, %13, %14 : i256 loc(#loc205) -// CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc205) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc205) -// CHECK-NEXT: } loc(#loc205) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: llvm.store %14, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc205) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc205) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc205) +// CHECK-NEXT: %5 = arith.addi %3, %c224_i256 : i256 loc(#loc205) +// CHECK-NEXT: %6:2 = scf.for %arg1 = %c0 to %c3 step %c1 iter_args(%arg2 = %4, %arg3 = %1) -> (i256, i256) { +// CHECK-NEXT: %14 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %15 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc205) +// CHECK-NEXT: "llvm.intr.memcpy"(%14, %15, %c64_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc205) +// CHECK-NEXT: %16 = arith.addi %arg2, %c64_i256 : i256 loc(#loc205) +// CHECK-NEXT: %17 = arith.addi %arg3, %c64_i256 : i256 loc(#loc205) +// CHECK-NEXT: scf.yield %16, %17 : i256, i256 loc(#loc205) +// CHECK-NEXT: } loc(#loc205) +// CHECK-NEXT: %7 = arith.subi %5, %4 : i256 loc(#loc205) +// CHECK-NEXT: %8 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %7, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %9 = arith.addi %3, %c224_i256 : i256 loc(#loc205) +// CHECK-NEXT: %10 = arith.cmpi ugt, %9, %c18446744073709551615_i256 : i256 loc(#loc205) +// CHECK-NEXT: %11 = arith.cmpi ult, %9, %3 : i256 loc(#loc205) +// CHECK-NEXT: %12 = arith.ori %10, %11 : i1 loc(#loc205) +// CHECK-NEXT: scf.if %12 { +// CHECK-NEXT: %14 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %15 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %c65_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %16 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: "llvm.intrcall"(%16, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc205) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc205) // CHECK-NEXT: } loc(#loc205) -// CHECK-NEXT: %9 = arith.subi %8#0, %4 : i256 loc(#loc205) -// CHECK-NEXT: %10 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: llvm.store %9, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc205) -// CHECK-NEXT: llvm.store %8#0, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc205) +// CHECK-NEXT: llvm.store %9, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc205) // CHECK-NEXT: return %3 : i256 loc(#loc206) // CHECK-NEXT: } loc(#loc202) -// CHECK-NEXT: func.func @encode_array_calldata_bytes5_624(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:164:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_bool_645(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:164:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) -// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -3645,142 +5374,593 @@ contract StorageBytes { // CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc210) // CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc210) // CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { -// CHECK-NEXT: %19 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc210) -// CHECK-NEXT: %20 = llvm.load %19 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc210) -// CHECK-NEXT: %21 = arith.andi %20, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc210) -// CHECK-NEXT: %22 = arith.cmpi ne, %20, %21 : i256 loc(#loc210) -// CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: "llvm.intrcall"(%26, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc210) +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc210) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc210) +// CHECK-NEXT: %28 = arith.cmpi ne, %27, %c0_i256 : i256 loc(#loc210) +// CHECK-NEXT: %29 = arith.extui %28 : i1 to i256 loc(#loc210) +// CHECK-NEXT: %30 = arith.cmpi ne, %27, %29 : i256 loc(#loc210) +// CHECK-NEXT: scf.if %30 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: "llvm.intrcall"(%34, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc210) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc210) // CHECK-NEXT: } loc(#loc210) -// CHECK-NEXT: %23 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: llvm.store %21, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: %24 = arith.addi %arg2, %c32_i256 : i256 loc(#loc210) -// CHECK-NEXT: %25 = arith.addi %arg3, %c32_i256 : i256 loc(#loc210) -// CHECK-NEXT: scf.yield %24, %25 : i256, i256 loc(#loc210) +// CHECK-NEXT: %31 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %29, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %32 = arith.addi %arg2, %c32_i256 : i256 loc(#loc210) +// CHECK-NEXT: %33 = arith.addi %arg3, %c32_i256 : i256 loc(#loc210) +// CHECK-NEXT: scf.yield %32, %33 : i256, i256 loc(#loc210) // CHECK-NEXT: } loc(#loc210) // CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc210) // CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc210) // CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: %18 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc210) -// CHECK-NEXT: llvm.store %14, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc210) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc210) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc210) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc210) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc210) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc210) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc210) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc210) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc210) +// CHECK-NEXT: } loc(#loc210) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc210) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc210) // CHECK-NEXT: return %3 : i256 loc(#loc211) // CHECK-NEXT: } loc(#loc207) -// CHECK-NEXT: func.func @encode_selector_640(%arg0: i256 loc({{.*}}:168:25), %arg1: i256 loc({{.*}}:168:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @encode_array_calldata_enum_660(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:168:36)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc213) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc213) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc213) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc214) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc215) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc215) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc215) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc215) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc215) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc215) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc215) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc215) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc215) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc215) +// CHECK-NEXT: %28 = arith.cmpi ugt, %27, %c2_i256 : i256 loc(#loc215) +// CHECK-NEXT: scf.if %28 { +// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: "llvm.intrcall"(%32, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc215) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc215) +// CHECK-NEXT: } loc(#loc215) +// CHECK-NEXT: %29 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %27, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %30 = arith.addi %arg2, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %31 = arith.addi %arg3, %c32_i256 : i256 loc(#loc215) +// CHECK-NEXT: scf.yield %30, %31 : i256, i256 loc(#loc215) +// CHECK-NEXT: } loc(#loc215) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc215) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc215) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc215) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc215) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc215) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc215) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc215) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc215) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc215) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc215) +// CHECK-NEXT: } loc(#loc215) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc215) +// CHECK-NEXT: return %3 : i256 loc(#loc216) +// CHECK-NEXT: } loc(#loc212) +// CHECK-NEXT: func.func @encode_array_calldata_address_674(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:172:39)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc218) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc218) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc218) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc219) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc220) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc220) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc220) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc220) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc220) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc220) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc220) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc220) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc220) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc220) +// CHECK-NEXT: %28 = arith.andi %27, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc220) +// CHECK-NEXT: %29 = arith.cmpi ne, %27, %28 : i256 loc(#loc220) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc220) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc220) +// CHECK-NEXT: } loc(#loc220) +// CHECK-NEXT: %30 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %28, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %31 = arith.addi %arg2, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc220) +// CHECK-NEXT: scf.yield %31, %32 : i256, i256 loc(#loc220) +// CHECK-NEXT: } loc(#loc220) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc220) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc220) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc220) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc220) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc220) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc220) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc220) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc220) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc220) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc220) +// CHECK-NEXT: } loc(#loc220) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc220) +// CHECK-NEXT: return %3 : i256 loc(#loc221) +// CHECK-NEXT: } loc(#loc217) +// CHECK-NEXT: func.func @encode_array_calldata_contract_689(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:176:40)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc223) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc223) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc223) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc224) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc225) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc225) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc225) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc225) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc225) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc225) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc225) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc225) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc225) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc225) +// CHECK-NEXT: %28 = arith.andi %27, %c1461501637330902918203684832716283019655932542975_i256 : i256 loc(#loc225) +// CHECK-NEXT: %29 = arith.cmpi ne, %27, %28 : i256 loc(#loc225) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc225) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc225) +// CHECK-NEXT: } loc(#loc225) +// CHECK-NEXT: %30 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %28, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %31 = arith.addi %arg2, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc225) +// CHECK-NEXT: scf.yield %31, %32 : i256, i256 loc(#loc225) +// CHECK-NEXT: } loc(#loc225) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc225) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc225) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc225) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc225) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc225) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc225) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc225) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc225) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc225) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc225) +// CHECK-NEXT: } loc(#loc225) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc225) +// CHECK-NEXT: return %3 : i256 loc(#loc226) +// CHECK-NEXT: } loc(#loc222) +// CHECK-NEXT: func.func @encode_packed_calldata_array_bytes5_703(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:180:45)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc228) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc228) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc228) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc229) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc230) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %5 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc230) +// CHECK-NEXT: %6 = arith.index_castui %5 : i256 to index loc(#loc230) +// CHECK-NEXT: %7 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc230) +// CHECK-NEXT: %8 = arith.muli %5, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %9 = arith.addi %4, %8 : i256 loc(#loc230) +// CHECK-NEXT: %10:2 = scf.for %arg1 = %c0 to %6 step %c1 iter_args(%arg2 = %4, %arg3 = %7) -> (i256, i256) { +// CHECK-NEXT: %20 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc230) +// CHECK-NEXT: %21 = llvm.load %20 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc230) +// CHECK-NEXT: %22 = arith.andi %21, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc230) +// CHECK-NEXT: %23 = arith.cmpi ne, %21, %22 : i256 loc(#loc230) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc230) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc230) +// CHECK-NEXT: } loc(#loc230) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %22, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc230) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc230) +// CHECK-NEXT: } loc(#loc230) +// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %8, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %12 = arith.subi %9, %3 : i256 loc(#loc230) +// CHECK-NEXT: %13 = arith.addi %12, %c31_i256 : i256 loc(#loc230) +// CHECK-NEXT: %14 = arith.andi %13, %c-32_i256 : i256 loc(#loc230) +// CHECK-NEXT: %15 = arith.addi %3, %14 : i256 loc(#loc230) +// CHECK-NEXT: %16 = arith.cmpi ugt, %15, %c18446744073709551615_i256 : i256 loc(#loc230) +// CHECK-NEXT: %17 = arith.cmpi ult, %15, %3 : i256 loc(#loc230) +// CHECK-NEXT: %18 = arith.ori %16, %17 : i1 loc(#loc230) +// CHECK-NEXT: scf.if %18 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc230) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc230) +// CHECK-NEXT: } loc(#loc230) +// CHECK-NEXT: %19 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: llvm.store %15, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc230) +// CHECK-NEXT: return %3 : i256 loc(#loc231) +// CHECK-NEXT: } loc(#loc227) +// CHECK-NEXT: func.func @encode_array_calldata_bytes5_717(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:184:38)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c-105312291668557186697918027683670432318895095400549111254310977536_i256 = arith.constant -105312291668557186697918027683670432318895095400549111254310977536 : i256 loc(#loc) +// CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) +// CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) +// CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc233) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x !llvm.struct<(i256, i256)> : (i256) -> !llvm.ptr loc(#loc233) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : !llvm.struct<(i256, i256)>, !llvm.ptr loc(#loc233) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> !llvm.struct<(i256, i256)> loc(#loc234) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc235) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc235) +// CHECK-NEXT: %6 = arith.subi %5, %4 : i256 loc(#loc235) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %8 = llvm.extractvalue %1[1] : !llvm.struct<(i256, i256)> loc(#loc235) +// CHECK-NEXT: %9 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %10 = arith.index_castui %8 : i256 to index loc(#loc235) +// CHECK-NEXT: %11 = arith.addi %3, %c96_i256 : i256 loc(#loc235) +// CHECK-NEXT: %12 = llvm.extractvalue %1[0] : !llvm.struct<(i256, i256)> loc(#loc235) +// CHECK-NEXT: %13 = arith.muli %8, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %14 = arith.addi %11, %13 : i256 loc(#loc235) +// CHECK-NEXT: %15:2 = scf.for %arg1 = %c0 to %10 step %c1 iter_args(%arg2 = %11, %arg3 = %12) -> (i256, i256) { +// CHECK-NEXT: %26 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<2> loc(#loc235) +// CHECK-NEXT: %27 = llvm.load %26 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc235) +// CHECK-NEXT: %28 = arith.andi %27, %c-105312291668557186697918027683670432318895095400549111254310977536_i256 : i256 loc(#loc235) +// CHECK-NEXT: %29 = arith.cmpi ne, %27, %28 : i256 loc(#loc235) +// CHECK-NEXT: scf.if %29 { +// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc235) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc235) +// CHECK-NEXT: } loc(#loc235) +// CHECK-NEXT: %30 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %28, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %31 = arith.addi %arg2, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %32 = arith.addi %arg3, %c32_i256 : i256 loc(#loc235) +// CHECK-NEXT: scf.yield %31, %32 : i256, i256 loc(#loc235) +// CHECK-NEXT: } loc(#loc235) +// CHECK-NEXT: %16 = arith.subi %14, %4 : i256 loc(#loc235) +// CHECK-NEXT: %17 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %16, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %18 = arith.subi %14, %3 : i256 loc(#loc235) +// CHECK-NEXT: %19 = arith.addi %18, %c31_i256 : i256 loc(#loc235) +// CHECK-NEXT: %20 = arith.andi %19, %c-32_i256 : i256 loc(#loc235) +// CHECK-NEXT: %21 = arith.addi %3, %20 : i256 loc(#loc235) +// CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c18446744073709551615_i256 : i256 loc(#loc235) +// CHECK-NEXT: %23 = arith.cmpi ult, %21, %3 : i256 loc(#loc235) +// CHECK-NEXT: %24 = arith.ori %22, %23 : i1 loc(#loc235) +// CHECK-NEXT: scf.if %24 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc235) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc235) +// CHECK-NEXT: } loc(#loc235) +// CHECK-NEXT: %25 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: llvm.store %21, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc235) +// CHECK-NEXT: return %3 : i256 loc(#loc236) +// CHECK-NEXT: } loc(#loc232) +// CHECK-NEXT: func.func @encode_selector_733(%arg0: i256 loc({{.*}}:188:25), %arg1: i256 loc({{.*}}:188:37)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc213) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc213) -// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc214) -// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc214) -// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc215) -// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc216) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc217) -// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc217) -// CHECK-NEXT: %7 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %8 = arith.addi %5, %c36_i256 : i256 loc(#loc217) -// CHECK-NEXT: %9 = arith.addi %5, %c68_i256 : i256 loc(#loc217) -// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %11 = arith.subi %9, %6 : i256 loc(#loc217) -// CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: %13 = arith.addi %5, %c68_i256 : i256 loc(#loc217) -// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: llvm.store %13, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc217) -// CHECK-NEXT: return %5 : i256 loc(#loc218) -// CHECK-NEXT: } loc(#loc212) -// CHECK-NEXT: func.func @encode_fnptr_659(%arg0: i256 loc({{.*}}:172:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc238) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc238) +// CHECK-NEXT: %1 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc239) +// CHECK-NEXT: llvm.store %arg1, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc239) +// CHECK-NEXT: %2 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc240) +// CHECK-NEXT: %3 = llvm.load %1 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc241) +// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc242) +// CHECK-NEXT: %6 = arith.addi %5, %c32_i256 : i256 loc(#loc242) +// CHECK-NEXT: %7 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %2, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %8 = arith.addi %5, %c36_i256 : i256 loc(#loc242) +// CHECK-NEXT: %9 = arith.addi %5, %c68_i256 : i256 loc(#loc242) +// CHECK-NEXT: %10 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %3, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %11 = arith.subi %9, %6 : i256 loc(#loc242) +// CHECK-NEXT: %12 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %11, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %13 = arith.addi %5, %c96_i256 : i256 loc(#loc242) +// CHECK-NEXT: %14 = arith.cmpi ugt, %13, %c18446744073709551615_i256 : i256 loc(#loc242) +// CHECK-NEXT: %15 = arith.cmpi ult, %13, %5 : i256 loc(#loc242) +// CHECK-NEXT: %16 = arith.ori %14, %15 : i1 loc(#loc242) +// CHECK-NEXT: scf.if %16 { +// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %19 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %c65_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: "llvm.intrcall"(%20, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc242) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc242) +// CHECK-NEXT: } loc(#loc242) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: llvm.store %13, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc242) +// CHECK-NEXT: return %5 : i256 loc(#loc243) +// CHECK-NEXT: } loc(#loc237) +// CHECK-NEXT: func.func @encode_fnptr_752(%arg0: i256 loc({{.*}}:192:22)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-18446744073709551616_i256 = arith.constant -18446744073709551616 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc220) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc220) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc220) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc221) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc222) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc222) -// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc222) -// CHECK-NEXT: %6 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc222) -// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc222) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc222) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc222) -// CHECK-NEXT: return %3 : i256 loc(#loc223) -// CHECK-NEXT: } loc(#loc219) -// CHECK-NEXT: func.func @encode_packed_fnptr_678(%arg0: i256 loc({{.*}}:176:29)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc245) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc245) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc245) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc246) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc247) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc247) +// CHECK-NEXT: %5 = arith.addi %3, %c64_i256 : i256 loc(#loc247) +// CHECK-NEXT: %6 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc247) +// CHECK-NEXT: %7 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %8 = arith.subi %5, %4 : i256 loc(#loc247) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc247) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc247) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc247) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc247) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc247) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc247) +// CHECK-NEXT: } loc(#loc247) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc247) +// CHECK-NEXT: return %3 : i256 loc(#loc248) +// CHECK-NEXT: } loc(#loc244) +// CHECK-NEXT: func.func @encode_packed_fnptr_771(%arg0: i256 loc({{.*}}:196:29)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c56_i256 = arith.constant 56 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-18446744073709551616_i256 = arith.constant -18446744073709551616 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc225) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc225) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc225) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc226) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc227) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc227) -// CHECK-NEXT: %5 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc227) -// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: %7 = arith.addi %3, %c56_i256 : i256 loc(#loc227) -// CHECK-NEXT: %8 = arith.subi %7, %4 : i256 loc(#loc227) -// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: %10 = arith.addi %3, %c56_i256 : i256 loc(#loc227) -// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc227) -// CHECK-NEXT: return %3 : i256 loc(#loc228) -// CHECK-NEXT: } loc(#loc224) -// CHECK-NEXT: func.func @encode_packed_fnptr_array_698(%arg0: i256 loc({{.*}}:180:35)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc250) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc250) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc250) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc251) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc252) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc252) +// CHECK-NEXT: %5 = arith.andi %1, %c-18446744073709551616_i256 : i256 loc(#loc252) +// CHECK-NEXT: %6 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %5, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %7 = arith.addi %3, %c56_i256 : i256 loc(#loc252) +// CHECK-NEXT: %8 = arith.subi %7, %4 : i256 loc(#loc252) +// CHECK-NEXT: %9 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %10 = arith.addi %3, %c64_i256 : i256 loc(#loc252) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc252) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %3 : i256 loc(#loc252) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc252) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %15 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %16 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %c65_i256, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: "llvm.intrcall"(%17, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc252) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc252) +// CHECK-NEXT: } loc(#loc252) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc252) +// CHECK-NEXT: return %3 : i256 loc(#loc253) +// CHECK-NEXT: } loc(#loc249) +// CHECK-NEXT: func.func @encode_packed_fnptr_array_791(%arg0: i256 loc({{.*}}:200:35)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c-18446744073709551616_i256 = arith.constant -18446744073709551616 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc230) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc230) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc230) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc231) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc232) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc232) -// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc232) -// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: %9:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { -// CHECK-NEXT: %13 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc232) -// CHECK-NEXT: %15 = arith.andi %14, %c-18446744073709551616_i256 : i256 loc(#loc232) -// CHECK-NEXT: %16 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %17 = arith.addi %arg2, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: %18 = arith.addi %arg3, %c32_i256 : i256 loc(#loc232) -// CHECK-NEXT: scf.yield %17, %18 : i256, i256 loc(#loc232) -// CHECK-NEXT: } loc(#loc232) -// CHECK-NEXT: %10 = arith.subi %9#0, %4 : i256 loc(#loc232) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: llvm.store %10, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: llvm.store %9#0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc232) -// CHECK-NEXT: return %3 : i256 loc(#loc233) -// CHECK-NEXT: } loc(#loc229) -// CHECK-NEXT: func.func @StorageBytes_740() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc255) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc255) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc255) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc256) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc257) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %5 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %6 = llvm.load %5 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc257) +// CHECK-NEXT: %7 = arith.index_castui %6 : i256 to index loc(#loc257) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %9 = arith.muli %6, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %10 = arith.addi %4, %9 : i256 loc(#loc257) +// CHECK-NEXT: %11:2 = scf.for %arg1 = %c0 to %7 step %c1 iter_args(%arg2 = %4, %arg3 = %8) -> (i256, i256) { +// CHECK-NEXT: %21 = llvm.inttoptr %arg3 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %22 = llvm.load %21 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc257) +// CHECK-NEXT: %23 = arith.andi %22, %c-18446744073709551616_i256 : i256 loc(#loc257) +// CHECK-NEXT: %24 = llvm.inttoptr %arg2 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %23, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %25 = arith.addi %arg2, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %26 = arith.addi %arg3, %c32_i256 : i256 loc(#loc257) +// CHECK-NEXT: scf.yield %25, %26 : i256, i256 loc(#loc257) +// CHECK-NEXT: } loc(#loc257) +// CHECK-NEXT: %12 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %9, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %13 = arith.subi %10, %3 : i256 loc(#loc257) +// CHECK-NEXT: %14 = arith.addi %13, %c31_i256 : i256 loc(#loc257) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc257) +// CHECK-NEXT: %16 = arith.addi %3, %15 : i256 loc(#loc257) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc257) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %3 : i256 loc(#loc257) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc257) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %22 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %c65_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: "llvm.intrcall"(%23, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc257) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc257) +// CHECK-NEXT: } loc(#loc257) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc257) +// CHECK-NEXT: return %3 : i256 loc(#loc258) +// CHECK-NEXT: } loc(#loc254) +// CHECK-NEXT: func.func @StorageBytes_833() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: return loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: module @StorageBytes_740_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { +// CHECK-NEXT: module @StorageBytes_833_deployed attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { // CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) @@ -3808,11 +5988,11 @@ contract StorageBytes { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %10 = func.call @ep_bytes_storage_713() : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_bytes_storage_806() : () -> i256 loc(#loc1) // CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) @@ -3825,14 +6005,17 @@ contract StorageBytes { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -3840,11 +6023,11 @@ contract StorageBytes { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %10 = func.call @ep_bytes_concat_storage_725() : () -> i256 loc(#loc1) +// CHECK-NEXT: %10 = func.call @ep_bytes_concat_storage_818() : () -> i256 loc(#loc1) // CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %13 = arith.addi %12, %c32_i256 : i256 loc(#loc1) @@ -3857,14 +6040,17 @@ contract StorageBytes { // CHECK-NEXT: %19 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %20 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%19, %20, %17) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %17, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %22 = arith.addi %17, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %23 = arith.andi %22, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.addi %15, %23 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.subi %24, %12 : i256 loc(#loc1) -// CHECK-NEXT: %26 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%26, %25) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = arith.addi %15, %17 : i256 loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.addi %15, %25 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.subi %26, %12 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %12 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%28, %27) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -3872,15 +6058,15 @@ contract StorageBytes { // CHECK-NEXT: %8 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %9 = arith.cmpi ne, %8, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%35, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %10 = arith.subi %1, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %11 = arith.cmpi slt, %10, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %11 { -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%35, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %12 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) @@ -3888,11 +6074,11 @@ contract StorageBytes { // CHECK-NEXT: %14 = arith.andi %13, %c-26959946667150639794667015087019630673637144422540572481103610249216_i256 : i256 loc(#loc1) // CHECK-NEXT: %15 = arith.cmpi ne, %13, %14 : i256 loc(#loc1) // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%33, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%35, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %16 = func.call @ews_bytes_bytes_storage_739(%13) : (i256) -> i256 loc(#loc1) +// CHECK-NEXT: %16 = func.call @ews_bytes_bytes_storage_832(%13) : (i256) -> i256 loc(#loc1) // CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %19 = arith.addi %18, %c32_i256 : i256 loc(#loc1) @@ -3905,14 +6091,17 @@ contract StorageBytes { // CHECK-NEXT: %25 = llvm.inttoptr %21 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %26 = llvm.inttoptr %24 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%25, %26, %23) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %23, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %28 = arith.addi %23, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %21, %29 : i256 loc(#loc1) -// CHECK-NEXT: %31 = arith.subi %30, %18 : i256 loc(#loc1) -// CHECK-NEXT: %32 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%32, %31) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %21, %23 : i256 loc(#loc1) +// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %23, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %30 = arith.addi %23, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.andi %30, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.addi %21, %31 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.subi %32, %18 : i256 loc(#loc1) +// CHECK-NEXT: %34 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%34, %33) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -3925,9 +6114,11 @@ contract StorageBytes { // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: func.func @ews_bytes_bytes_storage_739(%arg0: i256 loc({{.*}}:196:35)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: func.func @ews_bytes_bytes_storage_832(%arg0: i256 loc({{.*}}:216:35)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) @@ -3942,75 +6133,95 @@ contract StorageBytes { // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc235) -// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc235) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc236) -// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc237) -// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc237) -// CHECK-NEXT: %5 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %1, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %6 = arith.addi %3, %c36_i256 : i256 loc(#loc237) -// CHECK-NEXT: %7 = arith.addi %3, %c68_i256 : i256 loc(#loc237) -// CHECK-NEXT: %8 = arith.subi %7, %6 : i256 loc(#loc237) -// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %10 = arith.addi %3, %c100_i256 : i256 loc(#loc237) -// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc237) -// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc237) -// CHECK-NEXT: %13 = arith.shrui %12, %c1_i256 : i256 loc(#loc237) -// CHECK-NEXT: %14 = arith.andi %12, %c1_i256 : i256 loc(#loc237) -// CHECK-NEXT: %15 = arith.cmpi eq, %14, %c0_i256 : i256 loc(#loc237) -// CHECK-NEXT: %16 = arith.andi %13, %c127_i256 : i256 loc(#loc237) -// CHECK-NEXT: %17 = arith.select %15, %16, %13 : i256 loc(#loc237) -// CHECK-NEXT: %18 = arith.cmpi ult, %17, %c32_i256 : i256 loc(#loc237) -// CHECK-NEXT: %19 = arith.trunci %14 : i256 to i1 loc(#loc237) -// CHECK-NEXT: %20 = arith.cmpi eq, %19, %18 : i1 loc(#loc237) +// CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc260) +// CHECK-NEXT: llvm.store %arg0, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc260) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc261) +// CHECK-NEXT: %2 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %3 = llvm.load %2 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc262) +// CHECK-NEXT: %4 = arith.addi %3, %c32_i256 : i256 loc(#loc262) +// CHECK-NEXT: %5 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %1, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %6 = arith.addi %3, %c36_i256 : i256 loc(#loc262) +// CHECK-NEXT: %7 = arith.addi %3, %c68_i256 : i256 loc(#loc262) +// CHECK-NEXT: %8 = arith.subi %7, %6 : i256 loc(#loc262) +// CHECK-NEXT: %9 = llvm.inttoptr %6 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %10 = arith.addi %3, %c100_i256 : i256 loc(#loc262) +// CHECK-NEXT: %11 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc262) +// CHECK-NEXT: %12 = llvm.load %11 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc262) +// CHECK-NEXT: %13 = arith.shrui %12, %c1_i256 : i256 loc(#loc262) +// CHECK-NEXT: %14 = arith.andi %12, %c1_i256 : i256 loc(#loc262) +// CHECK-NEXT: %15 = arith.cmpi eq, %14, %c0_i256 : i256 loc(#loc262) +// CHECK-NEXT: %16 = arith.andi %13, %c127_i256 : i256 loc(#loc262) +// CHECK-NEXT: %17 = arith.select %15, %16, %13 : i256 loc(#loc262) +// CHECK-NEXT: %18 = arith.cmpi ult, %17, %c32_i256 : i256 loc(#loc262) +// CHECK-NEXT: %19 = arith.trunci %14 : i256 to i1 loc(#loc262) +// CHECK-NEXT: %20 = arith.cmpi eq, %19, %18 : i1 loc(#loc262) // CHECK-NEXT: scf.if %20 { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %31 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %c34_i256, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: "llvm.intrcall"(%32, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc237) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc237) -// CHECK-NEXT: } loc(#loc237) -// CHECK-NEXT: %21 = arith.andi %12, %c1_i256 : i256 loc(#loc237) -// CHECK-NEXT: %22 = arith.cmpi eq, %21, %c0_i256 : i256 loc(#loc237) +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %38 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %c34_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: "llvm.intrcall"(%39, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc262) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc262) +// CHECK-NEXT: } loc(#loc262) +// CHECK-NEXT: %21 = arith.andi %12, %c1_i256 : i256 loc(#loc262) +// CHECK-NEXT: %22 = arith.cmpi eq, %21, %c0_i256 : i256 loc(#loc262) // CHECK-NEXT: scf.if %22 { -// CHECK-NEXT: %30 = arith.andi %12, %c-256_i256 : i256 loc(#loc237) -// CHECK-NEXT: %31 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) +// CHECK-NEXT: %37 = arith.andi %12, %c-256_i256 : i256 loc(#loc262) +// CHECK-NEXT: %38 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %37, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) // CHECK-NEXT: } else { -// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %c0_i256, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %31 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %32 = "llvm.intrcall"(%31, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc237) -// CHECK-NEXT: %33 = arith.index_castui %17 : i256 to index loc(#loc237) -// CHECK-NEXT: scf.for %arg1 = %c0 to %33 step %c32 { -// CHECK-NEXT: %34 = arith.index_castui %arg1 : index to i256 loc(#loc237) -// CHECK-NEXT: %35 = arith.divui %34, %c32_i256 : i256 loc(#loc237) -// CHECK-NEXT: %36 = arith.addi %32, %35 : i256 loc(#loc237) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<5> loc(#loc237) -// CHECK-NEXT: %38 = llvm.load %37 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc237) -// CHECK-NEXT: %39 = arith.addi %10, %34 : i256 loc(#loc237) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %38, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: } loc(#loc237) -// CHECK-NEXT: } loc(#loc237) -// CHECK-NEXT: %23 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc237) -// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc237) -// CHECK-NEXT: %26 = arith.addi %10, %25 : i256 loc(#loc237) -// CHECK-NEXT: %27 = arith.subi %26, %4 : i256 loc(#loc237) -// CHECK-NEXT: %28 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: llvm.store %26, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc237) -// CHECK-NEXT: return %3 : i256 loc(#loc238) -// CHECK-NEXT: } loc(#loc234) -// CHECK-NEXT: func.func @ep_bytes_concat_storage_725() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %c0_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %39 = "llvm.intrcall"(%38, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc262) +// CHECK-NEXT: %40 = arith.index_castui %17 : i256 to index loc(#loc262) +// CHECK-NEXT: scf.for %arg1 = %c0 to %40 step %c32 { +// CHECK-NEXT: %41 = arith.index_castui %arg1 : index to i256 loc(#loc262) +// CHECK-NEXT: %42 = arith.divui %41, %c32_i256 : i256 loc(#loc262) +// CHECK-NEXT: %43 = arith.addi %39, %42 : i256 loc(#loc262) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<5> loc(#loc262) +// CHECK-NEXT: %45 = llvm.load %44 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc262) +// CHECK-NEXT: %46 = arith.addi %10, %41 : i256 loc(#loc262) +// CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %45, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: } loc(#loc262) +// CHECK-NEXT: } loc(#loc262) +// CHECK-NEXT: %23 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %17, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %24 = arith.addi %17, %c31_i256 : i256 loc(#loc262) +// CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc262) +// CHECK-NEXT: %26 = arith.addi %10, %25 : i256 loc(#loc262) +// CHECK-NEXT: %27 = arith.subi %26, %4 : i256 loc(#loc262) +// CHECK-NEXT: %28 = llvm.inttoptr %3 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %27, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %29 = arith.subi %26, %3 : i256 loc(#loc262) +// CHECK-NEXT: %30 = arith.addi %29, %c31_i256 : i256 loc(#loc262) +// CHECK-NEXT: %31 = arith.andi %30, %c-32_i256 : i256 loc(#loc262) +// CHECK-NEXT: %32 = arith.addi %3, %31 : i256 loc(#loc262) +// CHECK-NEXT: %33 = arith.cmpi ugt, %32, %c18446744073709551615_i256 : i256 loc(#loc262) +// CHECK-NEXT: %34 = arith.cmpi ult, %32, %3 : i256 loc(#loc262) +// CHECK-NEXT: %35 = arith.ori %33, %34 : i1 loc(#loc262) +// CHECK-NEXT: scf.if %35 { +// CHECK-NEXT: %37 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %38 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %c65_i256, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: "llvm.intrcall"(%39, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc262) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc262) +// CHECK-NEXT: } loc(#loc262) +// CHECK-NEXT: %36 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: llvm.store %32, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc262) +// CHECK-NEXT: return %3 : i256 loc(#loc263) +// CHECK-NEXT: } loc(#loc259) +// CHECK-NEXT: func.func @ep_bytes_concat_storage_818() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) @@ -4023,103 +6234,123 @@ contract StorageBytes { // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc240) -// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc240) -// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc240) -// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc240) -// CHECK-NEXT: %5 = arith.shrui %4, %c1_i256 : i256 loc(#loc240) -// CHECK-NEXT: %6 = arith.andi %4, %c1_i256 : i256 loc(#loc240) -// CHECK-NEXT: %7 = arith.cmpi eq, %6, %c0_i256 : i256 loc(#loc240) -// CHECK-NEXT: %8 = arith.andi %5, %c127_i256 : i256 loc(#loc240) -// CHECK-NEXT: %9 = arith.select %7, %8, %5 : i256 loc(#loc240) -// CHECK-NEXT: %10 = arith.cmpi ult, %9, %c32_i256 : i256 loc(#loc240) -// CHECK-NEXT: %11 = arith.trunci %6 : i256 to i1 loc(#loc240) -// CHECK-NEXT: %12 = arith.cmpi eq, %11, %10 : i1 loc(#loc240) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc265) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc265) +// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc265) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc265) +// CHECK-NEXT: %5 = arith.shrui %4, %c1_i256 : i256 loc(#loc265) +// CHECK-NEXT: %6 = arith.andi %4, %c1_i256 : i256 loc(#loc265) +// CHECK-NEXT: %7 = arith.cmpi eq, %6, %c0_i256 : i256 loc(#loc265) +// CHECK-NEXT: %8 = arith.andi %5, %c127_i256 : i256 loc(#loc265) +// CHECK-NEXT: %9 = arith.select %7, %8, %5 : i256 loc(#loc265) +// CHECK-NEXT: %10 = arith.cmpi ult, %9, %c32_i256 : i256 loc(#loc265) +// CHECK-NEXT: %11 = arith.trunci %6 : i256 to i1 loc(#loc265) +// CHECK-NEXT: %12 = arith.cmpi eq, %11, %10 : i1 loc(#loc265) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %c34_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc240) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc240) -// CHECK-NEXT: } loc(#loc240) -// CHECK-NEXT: %13 = arith.andi %4, %c1_i256 : i256 loc(#loc240) -// CHECK-NEXT: %14 = arith.cmpi eq, %13, %c0_i256 : i256 loc(#loc240) +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %40 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: "llvm.intrcall"(%41, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc265) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc265) +// CHECK-NEXT: } loc(#loc265) +// CHECK-NEXT: %13 = arith.andi %4, %c1_i256 : i256 loc(#loc265) +// CHECK-NEXT: %14 = arith.cmpi eq, %13, %c0_i256 : i256 loc(#loc265) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %32 = arith.andi %4, %c-256_i256 : i256 loc(#loc240) -// CHECK-NEXT: %33 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) +// CHECK-NEXT: %39 = arith.andi %4, %c-256_i256 : i256 loc(#loc265) +// CHECK-NEXT: %40 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) // CHECK-NEXT: } else { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %c0_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %34 = "llvm.intrcall"(%33, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc240) -// CHECK-NEXT: %35 = arith.index_castui %9 : i256 to index loc(#loc240) -// CHECK-NEXT: scf.for %arg0 = %c0 to %35 step %c32 { -// CHECK-NEXT: %36 = arith.index_castui %arg0 : index to i256 loc(#loc240) -// CHECK-NEXT: %37 = arith.divui %36, %c32_i256 : i256 loc(#loc240) -// CHECK-NEXT: %38 = arith.addi %34, %37 : i256 loc(#loc240) -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<5> loc(#loc240) -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc240) -// CHECK-NEXT: %41 = arith.addi %2, %36 : i256 loc(#loc240) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %40, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: } loc(#loc240) -// CHECK-NEXT: } loc(#loc240) -// CHECK-NEXT: %15 = arith.addi %2, %9 : i256 loc(#loc240) -// CHECK-NEXT: %16 = llvm.inttoptr %c1_i256 : i256 to !llvm.ptr<5> loc(#loc240) -// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc240) -// CHECK-NEXT: %18 = arith.shrui %17, %c1_i256 : i256 loc(#loc240) -// CHECK-NEXT: %19 = arith.andi %17, %c1_i256 : i256 loc(#loc240) -// CHECK-NEXT: %20 = arith.cmpi eq, %19, %c0_i256 : i256 loc(#loc240) -// CHECK-NEXT: %21 = arith.andi %18, %c127_i256 : i256 loc(#loc240) -// CHECK-NEXT: %22 = arith.select %20, %21, %18 : i256 loc(#loc240) -// CHECK-NEXT: %23 = arith.cmpi ult, %22, %c32_i256 : i256 loc(#loc240) -// CHECK-NEXT: %24 = arith.trunci %19 : i256 to i1 loc(#loc240) -// CHECK-NEXT: %25 = arith.cmpi eq, %24, %23 : i1 loc(#loc240) +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c0_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %41 = "llvm.intrcall"(%40, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc265) +// CHECK-NEXT: %42 = arith.index_castui %9 : i256 to index loc(#loc265) +// CHECK-NEXT: scf.for %arg0 = %c0 to %42 step %c32 { +// CHECK-NEXT: %43 = arith.index_castui %arg0 : index to i256 loc(#loc265) +// CHECK-NEXT: %44 = arith.divui %43, %c32_i256 : i256 loc(#loc265) +// CHECK-NEXT: %45 = arith.addi %41, %44 : i256 loc(#loc265) +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<5> loc(#loc265) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc265) +// CHECK-NEXT: %48 = arith.addi %2, %43 : i256 loc(#loc265) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %47, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: } loc(#loc265) +// CHECK-NEXT: } loc(#loc265) +// CHECK-NEXT: %15 = arith.addi %2, %9 : i256 loc(#loc265) +// CHECK-NEXT: %16 = llvm.inttoptr %c1_i256 : i256 to !llvm.ptr<5> loc(#loc265) +// CHECK-NEXT: %17 = llvm.load %16 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc265) +// CHECK-NEXT: %18 = arith.shrui %17, %c1_i256 : i256 loc(#loc265) +// CHECK-NEXT: %19 = arith.andi %17, %c1_i256 : i256 loc(#loc265) +// CHECK-NEXT: %20 = arith.cmpi eq, %19, %c0_i256 : i256 loc(#loc265) +// CHECK-NEXT: %21 = arith.andi %18, %c127_i256 : i256 loc(#loc265) +// CHECK-NEXT: %22 = arith.select %20, %21, %18 : i256 loc(#loc265) +// CHECK-NEXT: %23 = arith.cmpi ult, %22, %c32_i256 : i256 loc(#loc265) +// CHECK-NEXT: %24 = arith.trunci %19 : i256 to i1 loc(#loc265) +// CHECK-NEXT: %25 = arith.cmpi eq, %24, %23 : i1 loc(#loc265) // CHECK-NEXT: scf.if %25 { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %33 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %c34_i256, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: "llvm.intrcall"(%34, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc240) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc240) -// CHECK-NEXT: } loc(#loc240) -// CHECK-NEXT: %26 = arith.andi %17, %c1_i256 : i256 loc(#loc240) -// CHECK-NEXT: %27 = arith.cmpi eq, %26, %c0_i256 : i256 loc(#loc240) +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %40 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c34_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: "llvm.intrcall"(%41, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc265) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc265) +// CHECK-NEXT: } loc(#loc265) +// CHECK-NEXT: %26 = arith.andi %17, %c1_i256 : i256 loc(#loc265) +// CHECK-NEXT: %27 = arith.cmpi eq, %26, %c0_i256 : i256 loc(#loc265) // CHECK-NEXT: scf.if %27 { -// CHECK-NEXT: %32 = arith.andi %17, %c-256_i256 : i256 loc(#loc240) -// CHECK-NEXT: %33 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %32, %33 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) +// CHECK-NEXT: %39 = arith.andi %17, %c-256_i256 : i256 loc(#loc265) +// CHECK-NEXT: %40 = llvm.inttoptr %15 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %39, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) // CHECK-NEXT: } else { -// CHECK-NEXT: %32 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %c1_i256, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %33 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %34 = "llvm.intrcall"(%33, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc240) -// CHECK-NEXT: %35 = arith.index_castui %22 : i256 to index loc(#loc240) -// CHECK-NEXT: scf.for %arg0 = %c0 to %35 step %c32 { -// CHECK-NEXT: %36 = arith.index_castui %arg0 : index to i256 loc(#loc240) -// CHECK-NEXT: %37 = arith.divui %36, %c32_i256 : i256 loc(#loc240) -// CHECK-NEXT: %38 = arith.addi %34, %37 : i256 loc(#loc240) -// CHECK-NEXT: %39 = llvm.inttoptr %38 : i256 to !llvm.ptr<5> loc(#loc240) -// CHECK-NEXT: %40 = llvm.load %39 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc240) -// CHECK-NEXT: %41 = arith.addi %15, %36 : i256 loc(#loc240) -// CHECK-NEXT: %42 = llvm.inttoptr %41 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %40, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: } loc(#loc240) -// CHECK-NEXT: } loc(#loc240) -// CHECK-NEXT: %28 = arith.addi %15, %22 : i256 loc(#loc240) -// CHECK-NEXT: %29 = arith.subi %28, %2 : i256 loc(#loc240) -// CHECK-NEXT: %30 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: llvm.store %28, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc240) -// CHECK-NEXT: return %1 : i256 loc(#loc241) -// CHECK-NEXT: } loc(#loc239) -// CHECK-NEXT: func.func @ep_bytes_storage_713() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c1_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %40 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %41 = "llvm.intrcall"(%40, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc265) +// CHECK-NEXT: %42 = arith.index_castui %22 : i256 to index loc(#loc265) +// CHECK-NEXT: scf.for %arg0 = %c0 to %42 step %c32 { +// CHECK-NEXT: %43 = arith.index_castui %arg0 : index to i256 loc(#loc265) +// CHECK-NEXT: %44 = arith.divui %43, %c32_i256 : i256 loc(#loc265) +// CHECK-NEXT: %45 = arith.addi %41, %44 : i256 loc(#loc265) +// CHECK-NEXT: %46 = llvm.inttoptr %45 : i256 to !llvm.ptr<5> loc(#loc265) +// CHECK-NEXT: %47 = llvm.load %46 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc265) +// CHECK-NEXT: %48 = arith.addi %15, %43 : i256 loc(#loc265) +// CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %47, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: } loc(#loc265) +// CHECK-NEXT: } loc(#loc265) +// CHECK-NEXT: %28 = arith.addi %15, %22 : i256 loc(#loc265) +// CHECK-NEXT: %29 = arith.subi %28, %2 : i256 loc(#loc265) +// CHECK-NEXT: %30 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %29, %30 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %31 = arith.subi %28, %1 : i256 loc(#loc265) +// CHECK-NEXT: %32 = arith.addi %31, %c31_i256 : i256 loc(#loc265) +// CHECK-NEXT: %33 = arith.andi %32, %c-32_i256 : i256 loc(#loc265) +// CHECK-NEXT: %34 = arith.addi %1, %33 : i256 loc(#loc265) +// CHECK-NEXT: %35 = arith.cmpi ugt, %34, %c18446744073709551615_i256 : i256 loc(#loc265) +// CHECK-NEXT: %36 = arith.cmpi ult, %34, %1 : i256 loc(#loc265) +// CHECK-NEXT: %37 = arith.ori %35, %36 : i1 loc(#loc265) +// CHECK-NEXT: scf.if %37 { +// CHECK-NEXT: %39 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %39 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %40 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %c65_i256, %40 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: "llvm.intrcall"(%41, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc265) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc265) +// CHECK-NEXT: } loc(#loc265) +// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: llvm.store %34, %38 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc265) +// CHECK-NEXT: return %1 : i256 loc(#loc266) +// CHECK-NEXT: } loc(#loc264) +// CHECK-NEXT: func.func @ep_bytes_storage_806() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) @@ -4132,63 +6363,79 @@ contract StorageBytes { // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc243) -// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc243) -// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc243) -// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc243) -// CHECK-NEXT: %5 = arith.shrui %4, %c1_i256 : i256 loc(#loc243) -// CHECK-NEXT: %6 = arith.andi %4, %c1_i256 : i256 loc(#loc243) -// CHECK-NEXT: %7 = arith.cmpi eq, %6, %c0_i256 : i256 loc(#loc243) -// CHECK-NEXT: %8 = arith.andi %5, %c127_i256 : i256 loc(#loc243) -// CHECK-NEXT: %9 = arith.select %7, %8, %5 : i256 loc(#loc243) -// CHECK-NEXT: %10 = arith.cmpi ult, %9, %c32_i256 : i256 loc(#loc243) -// CHECK-NEXT: %11 = arith.trunci %6 : i256 to i1 loc(#loc243) -// CHECK-NEXT: %12 = arith.cmpi eq, %11, %10 : i1 loc(#loc243) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc268) +// CHECK-NEXT: %2 = arith.addi %1, %c32_i256 : i256 loc(#loc268) +// CHECK-NEXT: %3 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<5> loc(#loc268) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc268) +// CHECK-NEXT: %5 = arith.shrui %4, %c1_i256 : i256 loc(#loc268) +// CHECK-NEXT: %6 = arith.andi %4, %c1_i256 : i256 loc(#loc268) +// CHECK-NEXT: %7 = arith.cmpi eq, %6, %c0_i256 : i256 loc(#loc268) +// CHECK-NEXT: %8 = arith.andi %5, %c127_i256 : i256 loc(#loc268) +// CHECK-NEXT: %9 = arith.select %7, %8, %5 : i256 loc(#loc268) +// CHECK-NEXT: %10 = arith.cmpi ult, %9, %c32_i256 : i256 loc(#loc268) +// CHECK-NEXT: %11 = arith.trunci %6 : i256 to i1 loc(#loc268) +// CHECK-NEXT: %12 = arith.cmpi eq, %11, %10 : i1 loc(#loc268) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: %19 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: llvm.store %c34_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: "llvm.intrcall"(%20, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc243) -// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc243) -// CHECK-NEXT: } loc(#loc243) -// CHECK-NEXT: %13 = arith.andi %4, %c1_i256 : i256 loc(#loc243) -// CHECK-NEXT: %14 = arith.cmpi eq, %13, %c0_i256 : i256 loc(#loc243) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %26 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %c34_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: "llvm.intrcall"(%27, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc268) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc268) +// CHECK-NEXT: } loc(#loc268) +// CHECK-NEXT: %13 = arith.andi %4, %c1_i256 : i256 loc(#loc268) +// CHECK-NEXT: %14 = arith.cmpi eq, %13, %c0_i256 : i256 loc(#loc268) // CHECK-NEXT: scf.if %14 { -// CHECK-NEXT: %18 = arith.andi %4, %c-256_i256 : i256 loc(#loc243) -// CHECK-NEXT: %19 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: llvm.store %18, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc243) +// CHECK-NEXT: %25 = arith.andi %4, %c-256_i256 : i256 loc(#loc268) +// CHECK-NEXT: %26 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %25, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) // CHECK-NEXT: } else { -// CHECK-NEXT: %18 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: llvm.store %c0_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: %20 = "llvm.intrcall"(%19, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc243) -// CHECK-NEXT: %21 = arith.index_castui %9 : i256 to index loc(#loc243) -// CHECK-NEXT: scf.for %arg0 = %c0 to %21 step %c32 { -// CHECK-NEXT: %22 = arith.index_castui %arg0 : index to i256 loc(#loc243) -// CHECK-NEXT: %23 = arith.divui %22, %c32_i256 : i256 loc(#loc243) -// CHECK-NEXT: %24 = arith.addi %20, %23 : i256 loc(#loc243) -// CHECK-NEXT: %25 = llvm.inttoptr %24 : i256 to !llvm.ptr<5> loc(#loc243) -// CHECK-NEXT: %26 = llvm.load %25 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc243) -// CHECK-NEXT: %27 = arith.addi %2, %22 : i256 loc(#loc243) -// CHECK-NEXT: %28 = llvm.inttoptr %27 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: llvm.store %26, %28 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: } loc(#loc243) -// CHECK-NEXT: } loc(#loc243) -// CHECK-NEXT: %15 = arith.addi %2, %9 : i256 loc(#loc243) -// CHECK-NEXT: %16 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: llvm.store %9, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: llvm.store %15, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc243) -// CHECK-NEXT: return %1 : i256 loc(#loc244) -// CHECK-NEXT: } loc(#loc242) +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %c0_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %27 = "llvm.intrcall"(%26, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc268) +// CHECK-NEXT: %28 = arith.index_castui %9 : i256 to index loc(#loc268) +// CHECK-NEXT: scf.for %arg0 = %c0 to %28 step %c32 { +// CHECK-NEXT: %29 = arith.index_castui %arg0 : index to i256 loc(#loc268) +// CHECK-NEXT: %30 = arith.divui %29, %c32_i256 : i256 loc(#loc268) +// CHECK-NEXT: %31 = arith.addi %27, %30 : i256 loc(#loc268) +// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<5> loc(#loc268) +// CHECK-NEXT: %33 = llvm.load %32 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc268) +// CHECK-NEXT: %34 = arith.addi %2, %29 : i256 loc(#loc268) +// CHECK-NEXT: %35 = llvm.inttoptr %34 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %33, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: } loc(#loc268) +// CHECK-NEXT: } loc(#loc268) +// CHECK-NEXT: %15 = arith.addi %2, %9 : i256 loc(#loc268) +// CHECK-NEXT: %16 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %9, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %17 = arith.subi %15, %1 : i256 loc(#loc268) +// CHECK-NEXT: %18 = arith.addi %17, %c31_i256 : i256 loc(#loc268) +// CHECK-NEXT: %19 = arith.andi %18, %c-32_i256 : i256 loc(#loc268) +// CHECK-NEXT: %20 = arith.addi %1, %19 : i256 loc(#loc268) +// CHECK-NEXT: %21 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc268) +// CHECK-NEXT: %22 = arith.cmpi ult, %20, %1 : i256 loc(#loc268) +// CHECK-NEXT: %23 = arith.ori %21, %22 : i1 loc(#loc268) +// CHECK-NEXT: scf.if %23 { +// CHECK-NEXT: %25 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %26 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %c65_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: "llvm.intrcall"(%27, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc268) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc268) +// CHECK-NEXT: } loc(#loc268) +// CHECK-NEXT: %24 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: llvm.store %20, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc268) +// CHECK-NEXT: return %1 : i256 loc(#loc269) +// CHECK-NEXT: } loc(#loc267) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: #loc = loc(unknown) -// CHECK-NEXT: #loc1 = loc({{.*}}:184:0) -// CHECK-NEXT: #loc2 = loc({{.*}}:15:9) +// CHECK-NEXT: #loc1 = loc({{.*}}:204:0) +// CHECK-NEXT: #loc2 = loc({{.*}}:11:9) // CHECK-NEXT: #loc3 = loc({{.*}}:2:0) // CHECK-NEXT: #loc4 = loc({{.*}}:3:9) // CHECK-NEXT: #loc5 = loc({{.*}}:3:2) @@ -4199,19 +6446,19 @@ contract StorageBytes { // CHECK-NEXT: #loc13 = loc({{.*}}:11:20) // CHECK-NEXT: #loc14 = loc({{.*}}:11:24) // CHECK-NEXT: #loc15 = loc({{.*}}:11:29) -// CHECK-NEXT: #loc16 = loc({{.*}}:11:9) -// CHECK-NEXT: #loc17 = loc({{.*}}:11:2) -// CHECK-NEXT: #loc18 = loc({{.*}}:14:0) -// CHECK-NEXT: #loc20 = loc({{.*}}:15:20) +// CHECK-NEXT: #loc16 = loc({{.*}}:11:2) +// CHECK-NEXT: #loc17 = loc({{.*}}:14:0) +// CHECK-NEXT: #loc19 = loc({{.*}}:15:20) +// CHECK-NEXT: #loc20 = loc({{.*}}:15:9) // CHECK-NEXT: #loc21 = loc({{.*}}:15:2) // CHECK-NEXT: #loc22 = loc({{.*}}:18:0) -// CHECK-NEXT: #loc26 = loc({{.*}}:19:26) -// CHECK-NEXT: #loc27 = loc({{.*}}:19:29) -// CHECK-NEXT: #loc28 = loc({{.*}}:19:32) -// CHECK-NEXT: #loc29 = loc({{.*}}:19:9) -// CHECK-NEXT: #loc30 = loc({{.*}}:19:2) -// CHECK-NEXT: #loc31 = loc({{.*}}:22:0) -// CHECK-NEXT: #loc33 = loc({{.*}}:23:20) +// CHECK-NEXT: #loc24 = loc({{.*}}:19:20) +// CHECK-NEXT: #loc25 = loc({{.*}}:19:9) +// CHECK-NEXT: #loc26 = loc({{.*}}:19:2) +// CHECK-NEXT: #loc27 = loc({{.*}}:22:0) +// CHECK-NEXT: #loc31 = loc({{.*}}:23:26) +// CHECK-NEXT: #loc32 = loc({{.*}}:23:29) +// CHECK-NEXT: #loc33 = loc({{.*}}:23:32) // CHECK-NEXT: #loc34 = loc({{.*}}:23:9) // CHECK-NEXT: #loc35 = loc({{.*}}:23:2) // CHECK-NEXT: #loc36 = loc({{.*}}:26:0) @@ -4219,62 +6466,62 @@ contract StorageBytes { // CHECK-NEXT: #loc39 = loc({{.*}}:27:9) // CHECK-NEXT: #loc40 = loc({{.*}}:27:2) // CHECK-NEXT: #loc41 = loc({{.*}}:30:0) -// CHECK-NEXT: #loc43 = loc({{.*}}:31:26) +// CHECK-NEXT: #loc43 = loc({{.*}}:31:20) // CHECK-NEXT: #loc44 = loc({{.*}}:31:9) // CHECK-NEXT: #loc45 = loc({{.*}}:31:2) // CHECK-NEXT: #loc46 = loc({{.*}}:34:0) -// CHECK-NEXT: #loc48 = loc({{.*}}:35:31) -// CHECK-NEXT: #loc49 = loc({{.*}}:35:20) -// CHECK-NEXT: #loc50 = loc({{.*}}:35:9) -// CHECK-NEXT: #loc51 = loc({{.*}}:35:2) -// CHECK-NEXT: #loc52 = loc({{.*}}:38:0) -// CHECK-NEXT: #loc55 = loc({{.*}}:39:31) -// CHECK-NEXT: #loc56 = loc({{.*}}:39:34) -// CHECK-NEXT: #loc57 = loc({{.*}}:39:20) -// CHECK-NEXT: #loc58 = loc({{.*}}:39:9) -// CHECK-NEXT: #loc59 = loc({{.*}}:39:2) -// CHECK-NEXT: #loc60 = loc({{.*}}:42:0) -// CHECK-NEXT: #loc62 = loc({{.*}}:43:39) -// CHECK-NEXT: #loc63 = loc({{.*}}:43:20) -// CHECK-NEXT: #loc64 = loc({{.*}}:43:9) -// CHECK-NEXT: #loc65 = loc({{.*}}:43:2) -// CHECK-NEXT: #loc66 = loc({{.*}}:50:0) -// CHECK-NEXT: #loc68 = loc({{.*}}:51:20) -// CHECK-NEXT: #loc69 = loc({{.*}}:51:9) -// CHECK-NEXT: #loc70 = loc({{.*}}:51:2) -// CHECK-NEXT: #loc71 = loc({{.*}}:54:0) -// CHECK-NEXT: #loc73 = loc({{.*}}:55:26) -// CHECK-NEXT: #loc74 = loc({{.*}}:55:9) -// CHECK-NEXT: #loc75 = loc({{.*}}:55:2) +// CHECK-NEXT: #loc48 = loc({{.*}}:35:20) +// CHECK-NEXT: #loc49 = loc({{.*}}:35:9) +// CHECK-NEXT: #loc50 = loc({{.*}}:35:2) +// CHECK-NEXT: #loc51 = loc({{.*}}:38:0) +// CHECK-NEXT: #loc53 = loc({{.*}}:39:26) +// CHECK-NEXT: #loc54 = loc({{.*}}:39:9) +// CHECK-NEXT: #loc55 = loc({{.*}}:39:2) +// CHECK-NEXT: #loc56 = loc({{.*}}:42:0) +// CHECK-NEXT: #loc58 = loc({{.*}}:43:31) +// CHECK-NEXT: #loc59 = loc({{.*}}:43:20) +// CHECK-NEXT: #loc60 = loc({{.*}}:43:9) +// CHECK-NEXT: #loc61 = loc({{.*}}:43:2) +// CHECK-NEXT: #loc62 = loc({{.*}}:46:0) +// CHECK-NEXT: #loc65 = loc({{.*}}:47:31) +// CHECK-NEXT: #loc66 = loc({{.*}}:47:34) +// CHECK-NEXT: #loc67 = loc({{.*}}:47:20) +// CHECK-NEXT: #loc68 = loc({{.*}}:47:9) +// CHECK-NEXT: #loc69 = loc({{.*}}:47:2) +// CHECK-NEXT: #loc70 = loc({{.*}}:50:0) +// CHECK-NEXT: #loc72 = loc({{.*}}:51:39) +// CHECK-NEXT: #loc73 = loc({{.*}}:51:20) +// CHECK-NEXT: #loc74 = loc({{.*}}:51:9) +// CHECK-NEXT: #loc75 = loc({{.*}}:51:2) // CHECK-NEXT: #loc76 = loc({{.*}}:58:0) // CHECK-NEXT: #loc78 = loc({{.*}}:59:20) // CHECK-NEXT: #loc79 = loc({{.*}}:59:9) // CHECK-NEXT: #loc80 = loc({{.*}}:59:2) // CHECK-NEXT: #loc81 = loc({{.*}}:62:0) -// CHECK-NEXT: #loc83 = loc({{.*}}:63:31) -// CHECK-NEXT: #loc84 = loc({{.*}}:63:20) -// CHECK-NEXT: #loc85 = loc({{.*}}:63:9) -// CHECK-NEXT: #loc86 = loc({{.*}}:63:2) -// CHECK-NEXT: #loc87 = loc({{.*}}:66:0) -// CHECK-NEXT: #loc89 = loc({{.*}}:67:20) -// CHECK-NEXT: #loc90 = loc({{.*}}:67:9) -// CHECK-NEXT: #loc91 = loc({{.*}}:67:2) -// CHECK-NEXT: #loc92 = loc({{.*}}:72:0) -// CHECK-NEXT: #loc94 = loc({{.*}}:73:26) -// CHECK-NEXT: #loc95 = loc({{.*}}:73:9) -// CHECK-NEXT: #loc96 = loc({{.*}}:73:2) -// CHECK-NEXT: #loc97 = loc({{.*}}:76:0) -// CHECK-NEXT: #loc99 = loc({{.*}}:77:26) -// CHECK-NEXT: #loc100 = loc({{.*}}:77:9) -// CHECK-NEXT: #loc101 = loc({{.*}}:77:2) -// CHECK-NEXT: #loc102 = loc({{.*}}:80:0) -// CHECK-NEXT: #loc104 = loc({{.*}}:81:26) -// CHECK-NEXT: #loc105 = loc({{.*}}:81:9) -// CHECK-NEXT: #loc106 = loc({{.*}}:81:2) -// CHECK-NEXT: #loc107 = loc({{.*}}:84:0) -// CHECK-NEXT: #loc109 = loc({{.*}}:85:26) -// CHECK-NEXT: #loc110 = loc({{.*}}:85:9) -// CHECK-NEXT: #loc111 = loc({{.*}}:85:2) +// CHECK-NEXT: #loc83 = loc({{.*}}:63:26) +// CHECK-NEXT: #loc84 = loc({{.*}}:63:9) +// CHECK-NEXT: #loc85 = loc({{.*}}:63:2) +// CHECK-NEXT: #loc86 = loc({{.*}}:66:0) +// CHECK-NEXT: #loc88 = loc({{.*}}:67:20) +// CHECK-NEXT: #loc89 = loc({{.*}}:67:9) +// CHECK-NEXT: #loc90 = loc({{.*}}:67:2) +// CHECK-NEXT: #loc91 = loc({{.*}}:70:0) +// CHECK-NEXT: #loc93 = loc({{.*}}:71:20) +// CHECK-NEXT: #loc94 = loc({{.*}}:71:9) +// CHECK-NEXT: #loc95 = loc({{.*}}:71:2) +// CHECK-NEXT: #loc96 = loc({{.*}}:74:0) +// CHECK-NEXT: #loc98 = loc({{.*}}:75:31) +// CHECK-NEXT: #loc99 = loc({{.*}}:75:20) +// CHECK-NEXT: #loc100 = loc({{.*}}:75:9) +// CHECK-NEXT: #loc101 = loc({{.*}}:75:2) +// CHECK-NEXT: #loc102 = loc({{.*}}:78:0) +// CHECK-NEXT: #loc104 = loc({{.*}}:79:20) +// CHECK-NEXT: #loc105 = loc({{.*}}:79:9) +// CHECK-NEXT: #loc106 = loc({{.*}}:79:2) +// CHECK-NEXT: #loc107 = loc({{.*}}:82:0) +// CHECK-NEXT: #loc109 = loc({{.*}}:83:20) +// CHECK-NEXT: #loc110 = loc({{.*}}:83:9) +// CHECK-NEXT: #loc111 = loc({{.*}}:83:2) // CHECK-NEXT: #loc112 = loc({{.*}}:88:0) // CHECK-NEXT: #loc114 = loc({{.*}}:89:26) // CHECK-NEXT: #loc115 = loc({{.*}}:89:9) @@ -4308,19 +6555,19 @@ contract StorageBytes { // CHECK-NEXT: #loc150 = loc({{.*}}:117:9) // CHECK-NEXT: #loc151 = loc({{.*}}:117:2) // CHECK-NEXT: #loc152 = loc({{.*}}:120:0) -// CHECK-NEXT: #loc154 = loc({{.*}}:121:20) +// CHECK-NEXT: #loc154 = loc({{.*}}:121:26) // CHECK-NEXT: #loc155 = loc({{.*}}:121:9) // CHECK-NEXT: #loc156 = loc({{.*}}:121:2) // CHECK-NEXT: #loc157 = loc({{.*}}:124:0) -// CHECK-NEXT: #loc159 = loc({{.*}}:125:20) +// CHECK-NEXT: #loc159 = loc({{.*}}:125:26) // CHECK-NEXT: #loc160 = loc({{.*}}:125:9) // CHECK-NEXT: #loc161 = loc({{.*}}:125:2) // CHECK-NEXT: #loc162 = loc({{.*}}:128:0) -// CHECK-NEXT: #loc164 = loc({{.*}}:129:20) +// CHECK-NEXT: #loc164 = loc({{.*}}:129:26) // CHECK-NEXT: #loc165 = loc({{.*}}:129:9) // CHECK-NEXT: #loc166 = loc({{.*}}:129:2) // CHECK-NEXT: #loc167 = loc({{.*}}:132:0) -// CHECK-NEXT: #loc169 = loc({{.*}}:133:20) +// CHECK-NEXT: #loc169 = loc({{.*}}:133:26) // CHECK-NEXT: #loc170 = loc({{.*}}:133:9) // CHECK-NEXT: #loc171 = loc({{.*}}:133:2) // CHECK-NEXT: #loc172 = loc({{.*}}:136:0) @@ -4348,7 +6595,7 @@ contract StorageBytes { // CHECK-NEXT: #loc200 = loc({{.*}}:157:9) // CHECK-NEXT: #loc201 = loc({{.*}}:157:2) // CHECK-NEXT: #loc202 = loc({{.*}}:160:0) -// CHECK-NEXT: #loc204 = loc({{.*}}:161:26) +// CHECK-NEXT: #loc204 = loc({{.*}}:161:20) // CHECK-NEXT: #loc205 = loc({{.*}}:161:9) // CHECK-NEXT: #loc206 = loc({{.*}}:161:2) // CHECK-NEXT: #loc207 = loc({{.*}}:164:0) @@ -4356,30 +6603,50 @@ contract StorageBytes { // CHECK-NEXT: #loc210 = loc({{.*}}:165:9) // CHECK-NEXT: #loc211 = loc({{.*}}:165:2) // CHECK-NEXT: #loc212 = loc({{.*}}:168:0) -// CHECK-NEXT: #loc215 = loc({{.*}}:169:32) -// CHECK-NEXT: #loc216 = loc({{.*}}:169:37) -// CHECK-NEXT: #loc217 = loc({{.*}}:169:9) -// CHECK-NEXT: #loc218 = loc({{.*}}:169:2) -// CHECK-NEXT: #loc219 = loc({{.*}}:172:0) -// CHECK-NEXT: #loc221 = loc({{.*}}:173:20) -// CHECK-NEXT: #loc222 = loc({{.*}}:173:9) -// CHECK-NEXT: #loc223 = loc({{.*}}:173:2) -// CHECK-NEXT: #loc224 = loc({{.*}}:176:0) -// CHECK-NEXT: #loc226 = loc({{.*}}:177:26) -// CHECK-NEXT: #loc227 = loc({{.*}}:177:9) -// CHECK-NEXT: #loc228 = loc({{.*}}:177:2) -// CHECK-NEXT: #loc229 = loc({{.*}}:180:0) -// CHECK-NEXT: #loc231 = loc({{.*}}:181:26) -// CHECK-NEXT: #loc232 = loc({{.*}}:181:9) -// CHECK-NEXT: #loc233 = loc({{.*}}:181:2) -// CHECK-NEXT: #loc234 = loc({{.*}}:196:2) -// CHECK-NEXT: #loc236 = loc({{.*}}:197:34) -// CHECK-NEXT: #loc237 = loc({{.*}}:197:11) -// CHECK-NEXT: #loc238 = loc({{.*}}:197:4) -// CHECK-NEXT: #loc239 = loc({{.*}}:192:2) -// CHECK-NEXT: #loc240 = loc({{.*}}:193:11) -// CHECK-NEXT: #loc241 = loc({{.*}}:193:4) -// CHECK-NEXT: #loc242 = loc({{.*}}:188:2) -// CHECK-NEXT: #loc243 = loc({{.*}}:189:11) -// CHECK-NEXT: #loc244 = loc({{.*}}:189:4) +// CHECK-NEXT: #loc214 = loc({{.*}}:169:20) +// CHECK-NEXT: #loc215 = loc({{.*}}:169:9) +// CHECK-NEXT: #loc216 = loc({{.*}}:169:2) +// CHECK-NEXT: #loc217 = loc({{.*}}:172:0) +// CHECK-NEXT: #loc219 = loc({{.*}}:173:20) +// CHECK-NEXT: #loc220 = loc({{.*}}:173:9) +// CHECK-NEXT: #loc221 = loc({{.*}}:173:2) +// CHECK-NEXT: #loc222 = loc({{.*}}:176:0) +// CHECK-NEXT: #loc224 = loc({{.*}}:177:20) +// CHECK-NEXT: #loc225 = loc({{.*}}:177:9) +// CHECK-NEXT: #loc226 = loc({{.*}}:177:2) +// CHECK-NEXT: #loc227 = loc({{.*}}:180:0) +// CHECK-NEXT: #loc229 = loc({{.*}}:181:26) +// CHECK-NEXT: #loc230 = loc({{.*}}:181:9) +// CHECK-NEXT: #loc231 = loc({{.*}}:181:2) +// CHECK-NEXT: #loc232 = loc({{.*}}:184:0) +// CHECK-NEXT: #loc234 = loc({{.*}}:185:20) +// CHECK-NEXT: #loc235 = loc({{.*}}:185:9) +// CHECK-NEXT: #loc236 = loc({{.*}}:185:2) +// CHECK-NEXT: #loc237 = loc({{.*}}:188:0) +// CHECK-NEXT: #loc240 = loc({{.*}}:189:32) +// CHECK-NEXT: #loc241 = loc({{.*}}:189:37) +// CHECK-NEXT: #loc242 = loc({{.*}}:189:9) +// CHECK-NEXT: #loc243 = loc({{.*}}:189:2) +// CHECK-NEXT: #loc244 = loc({{.*}}:192:0) +// CHECK-NEXT: #loc246 = loc({{.*}}:193:20) +// CHECK-NEXT: #loc247 = loc({{.*}}:193:9) +// CHECK-NEXT: #loc248 = loc({{.*}}:193:2) +// CHECK-NEXT: #loc249 = loc({{.*}}:196:0) +// CHECK-NEXT: #loc251 = loc({{.*}}:197:26) +// CHECK-NEXT: #loc252 = loc({{.*}}:197:9) +// CHECK-NEXT: #loc253 = loc({{.*}}:197:2) +// CHECK-NEXT: #loc254 = loc({{.*}}:200:0) +// CHECK-NEXT: #loc256 = loc({{.*}}:201:26) +// CHECK-NEXT: #loc257 = loc({{.*}}:201:9) +// CHECK-NEXT: #loc258 = loc({{.*}}:201:2) +// CHECK-NEXT: #loc259 = loc({{.*}}:216:2) +// CHECK-NEXT: #loc261 = loc({{.*}}:217:34) +// CHECK-NEXT: #loc262 = loc({{.*}}:217:11) +// CHECK-NEXT: #loc263 = loc({{.*}}:217:4) +// CHECK-NEXT: #loc264 = loc({{.*}}:212:2) +// CHECK-NEXT: #loc265 = loc({{.*}}:213:11) +// CHECK-NEXT: #loc266 = loc({{.*}}:213:4) +// CHECK-NEXT: #loc267 = loc({{.*}}:208:2) +// CHECK-NEXT: #loc268 = loc({{.*}}:209:11) +// CHECK-NEXT: #loc269 = loc({{.*}}:209:4) // CHECK-EMPTY: diff --git a/test/lit/mlirCodegen/EVM/modifier.sol b/test/lit/mlirCodegen/EVM/modifier.sol index 1ed365cf3..696ceaa90 100644 --- a/test/lit/mlirCodegen/EVM/modifier.sol +++ b/test/lit/mlirCodegen/EVM/modifier.sol @@ -22,6 +22,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -30,8 +37,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -39,22 +46,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_49() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_49_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_49_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_49_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/msg-data.sol b/test/lit/mlirCodegen/EVM/msg-data.sol index 3fda8595e..9f0b64274 100644 --- a/test/lit/mlirCodegen/EVM/msg-data.sol +++ b/test/lit/mlirCodegen/EVM/msg-data.sol @@ -12,6 +12,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -20,8 +27,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_11"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -29,22 +36,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_11() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_11_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_11_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_11_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_11_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/named-return.sol b/test/lit/mlirCodegen/EVM/named-return.sol index e22f227f2..e14baad53 100644 --- a/test/lit/mlirCodegen/EVM/named-return.sol +++ b/test/lit/mlirCodegen/EVM/named-return.sol @@ -24,6 +24,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -32,8 +39,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_73"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -41,22 +48,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_73() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_73_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_73_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_73_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_73_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/new.sol b/test/lit/mlirCodegen/EVM/new.sol index e0a82f5e6..dd922d09d 100644 --- a/test/lit/mlirCodegen/EVM/new.sol +++ b/test/lit/mlirCodegen/EVM/new.sol @@ -15,6 +15,13 @@ contract D { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -23,8 +30,8 @@ contract D { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -32,22 +39,36 @@ contract D { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_9() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_9_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_9_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -119,6 +140,13 @@ contract D { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -127,8 +155,8 @@ contract D { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_23"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -136,22 +164,36 @@ contract D { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @D_23() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_23_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_23_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["D_23_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["D_23_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -209,6 +251,12 @@ contract D { // CHECK-NEXT: func.func @g_22() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c17219911917854084299749778639755835327755045716242581057573779540915269926912_i256 = arith.constant 17219911917854084299749778639755835327755045716242581057573779540915269926912 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) @@ -261,17 +309,43 @@ contract D { // CHECK-NEXT: %21 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc3) // CHECK-NEXT: %22 = arith.cmpi ult, %21, %c32_i256 : i256 loc(#loc3) // CHECK-NEXT: %23 = scf.if %22 -> (i256) { -// CHECK-NEXT: %28 = arith.addi %13, %21 : i256 loc(#loc3) -// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %30 = arith.addi %13, %21 : i256 loc(#loc3) -// CHECK-NEXT: scf.yield %30 : i256 loc(#loc3) +// CHECK-NEXT: %28 = arith.addi %21, %c31_i256 : i256 loc(#loc3) +// CHECK-NEXT: %29 = arith.andi %28, %c-32_i256 : i256 loc(#loc3) +// CHECK-NEXT: %30 = arith.addi %13, %29 : i256 loc(#loc3) +// CHECK-NEXT: %31 = arith.cmpi ugt, %30, %c18446744073709551615_i256 : i256 loc(#loc3) +// CHECK-NEXT: %32 = arith.cmpi ult, %30, %13 : i256 loc(#loc3) +// CHECK-NEXT: %33 = arith.ori %31, %32 : i1 loc(#loc3) +// CHECK-NEXT: scf.if %33 { +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %37 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c65_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %38 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: "llvm.intrcall"(%38, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc3) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc3) +// CHECK-NEXT: } loc(#loc3) +// CHECK-NEXT: %34 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %30, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %35 = arith.addi %13, %21 : i256 loc(#loc3) +// CHECK-NEXT: scf.yield %35 : i256 loc(#loc3) // CHECK-NEXT: } else { // CHECK-NEXT: %28 = arith.addi %13, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %29 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %28, %29 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %30 = arith.addi %13, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: scf.yield %30 : i256 loc(#loc3) +// CHECK-NEXT: %29 = arith.cmpi ugt, %28, %c18446744073709551615_i256 : i256 loc(#loc3) +// CHECK-NEXT: %30 = arith.cmpi ult, %28, %13 : i256 loc(#loc3) +// CHECK-NEXT: %31 = arith.ori %29, %30 : i1 loc(#loc3) +// CHECK-NEXT: scf.if %31 { +// CHECK-NEXT: %34 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %34 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %35 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %c65_i256, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %36 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: "llvm.intrcall"(%36, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc3) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc3) +// CHECK-NEXT: } loc(#loc3) +// CHECK-NEXT: %32 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: llvm.store %28, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %33 = arith.addi %13, %c32_i256 : i256 loc(#loc3) +// CHECK-NEXT: scf.yield %33 : i256 loc(#loc3) // CHECK-NEXT: } loc(#loc3) // CHECK-NEXT: %24 = arith.subi %23, %13 : i256 loc(#loc3) // CHECK-NEXT: %25 = arith.cmpi slt, %24, %c32_i256 : i256 loc(#loc3) diff --git a/test/lit/mlirCodegen/EVM/require.sol b/test/lit/mlirCodegen/EVM/require.sol index 5e6e1d835..0746b8c7a 100644 --- a/test/lit/mlirCodegen/EVM/require.sol +++ b/test/lit/mlirCodegen/EVM/require.sol @@ -17,6 +17,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -25,8 +32,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_33"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -34,22 +41,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_33() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_33_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_33_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_33_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_33_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/revert.sol b/test/lit/mlirCodegen/EVM/revert.sol index 8341ffeb0..8c795509a 100644 --- a/test/lit/mlirCodegen/EVM/revert.sol +++ b/test/lit/mlirCodegen/EVM/revert.sol @@ -17,6 +17,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -25,8 +32,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_22"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -34,22 +41,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_22() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_22_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_22_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_22_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_22_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/send-transfer.sol b/test/lit/mlirCodegen/EVM/send-transfer.sol index 0ab316ff4..9320eb5b1 100644 --- a/test/lit/mlirCodegen/EVM/send-transfer.sol +++ b/test/lit/mlirCodegen/EVM/send-transfer.sol @@ -24,6 +24,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -32,8 +39,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Receiver_5"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -41,22 +48,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @Receiver_5() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Receiver_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Receiver_5_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Receiver_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Receiver_5_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -99,6 +120,14 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) @@ -108,22 +137,36 @@ contract C { // CHECK-NEXT: %3 = arith.subi %2, %1 : i256 loc(#loc1) // CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %6 = arith.addi %5, %3 : i256 loc(#loc1) -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %8 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %1 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%8, %9, %3) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %6 = arith.addi %3, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %7 = arith.andi %6, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %7 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.cmpi ugt, %8, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.cmpi ult, %8, %5 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.ori %9, %10 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %11 { +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %8, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %1 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%13, %14, %3) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @_9() : () -> () loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.load %10 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %12 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_52_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %13 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_52_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %14 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %15 = llvm.inttoptr %12 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%14, %15, %13) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %11 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%16, %13) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.load %15 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %17 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_52_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %18 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_52_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %20 = llvm.inttoptr %17 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%19, %20, %18) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%21, %18) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/special-fn.sol b/test/lit/mlirCodegen/EVM/special-fn.sol index 90a5e9835..2994a5b43 100644 --- a/test/lit/mlirCodegen/EVM/special-fn.sol +++ b/test/lit/mlirCodegen/EVM/special-fn.sol @@ -13,6 +13,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -21,8 +28,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_13"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -30,22 +37,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_13() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_13_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_13_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_13_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_13_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/state-var.sol b/test/lit/mlirCodegen/EVM/state-var.sol index d561c40f3..90c71d630 100644 --- a/test/lit/mlirCodegen/EVM/state-var.sol +++ b/test/lit/mlirCodegen/EVM/state-var.sol @@ -41,6 +41,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -49,8 +56,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_155"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -58,22 +65,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_155() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_155_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_155_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_155_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_155_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -236,9 +257,12 @@ contract C { // CHECK-NEXT: return loc(#loc6) // CHECK-NEXT: } loc(#loc6) // CHECK-NEXT: func.func @get_s_134() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) @@ -262,51 +286,64 @@ contract C { // CHECK-NEXT: %8 = arith.trunci %3 : i256 to i1 loc(#loc11) // CHECK-NEXT: %9 = arith.cmpi eq, %8, %7 : i1 loc(#loc11) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %23 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %c34_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: "llvm.intrcall"(%24, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc11) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %c34_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc11) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc11) // CHECK-NEXT: } loc(#loc11) // CHECK-NEXT: %10 = arith.addi %6, %c31_i256 : i256 loc(#loc11) // CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %12 = arith.addi %11, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc11) -// CHECK-NEXT: %15 = arith.addi %14, %12 : i256 loc(#loc11) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %6, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %18 = arith.addi %14, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %19 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %6, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %20 = arith.andi %1, %c1_i256 : i256 loc(#loc11) -// CHECK-NEXT: %21 = arith.cmpi eq, %20, %c0_i256 : i256 loc(#loc11) -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %22 = arith.andi %1, %c-256_i256 : i256 loc(#loc11) -// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc11) +// CHECK-NEXT: %14 = arith.addi %11, %c63_i256 : i256 loc(#loc11) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc11) +// CHECK-NEXT: %16 = arith.addi %13, %15 : i256 loc(#loc11) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc11) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %13 : i256 loc(#loc11) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc11) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc11) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc11) +// CHECK-NEXT: } loc(#loc11) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %6, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %22 = arith.addi %13, %c32_i256 : i256 loc(#loc11) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %6, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %24 = arith.andi %1, %c1_i256 : i256 loc(#loc11) +// CHECK-NEXT: %25 = arith.cmpi eq, %24, %c0_i256 : i256 loc(#loc11) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %26 = arith.andi %1, %c-256_i256 : i256 loc(#loc11) +// CHECK-NEXT: %27 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) // CHECK-NEXT: } else { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %c6_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: %24 = "llvm.intrcall"(%23, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc11) -// CHECK-NEXT: %25 = arith.index_castui %6 : i256 to index loc(#loc11) -// CHECK-NEXT: scf.for %arg0 = %c0 to %25 step %c32 { -// CHECK-NEXT: %26 = arith.index_castui %arg0 : index to i256 loc(#loc11) -// CHECK-NEXT: %27 = arith.divui %26, %c32_i256 : i256 loc(#loc11) -// CHECK-NEXT: %28 = arith.addi %24, %27 : i256 loc(#loc11) -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<5> loc(#loc11) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc11) -// CHECK-NEXT: %31 = arith.addi %18, %26 : i256 loc(#loc11) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc11) -// CHECK-NEXT: llvm.store %30, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %c6_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: %28 = "llvm.intrcall"(%27, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc11) +// CHECK-NEXT: %29 = arith.index_castui %6 : i256 to index loc(#loc11) +// CHECK-NEXT: scf.for %arg0 = %c0 to %29 step %c32 { +// CHECK-NEXT: %30 = arith.index_castui %arg0 : index to i256 loc(#loc11) +// CHECK-NEXT: %31 = arith.divui %30, %c32_i256 : i256 loc(#loc11) +// CHECK-NEXT: %32 = arith.addi %28, %31 : i256 loc(#loc11) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<5> loc(#loc11) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc11) +// CHECK-NEXT: %35 = arith.addi %22, %30 : i256 loc(#loc11) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc11) +// CHECK-NEXT: llvm.store %34, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc11) // CHECK-NEXT: } loc(#loc11) // CHECK-NEXT: } loc(#loc11) -// CHECK-NEXT: return %14 : i256 loc(#loc12) +// CHECK-NEXT: return %13 : i256 loc(#loc12) // CHECK-NEXT: } loc(#loc10) // CHECK-NEXT: func.func @set_mc1_126(%arg0: i256 loc({{.*}}:18:19), %arg1: i256 loc({{.*}}:18:27)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c-1461501637330902918203684832716283019655932542976_i256 = arith.constant -1461501637330902918203684832716283019655932542976 : i256 loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/storage-array.sol b/test/lit/mlirCodegen/EVM/storage-array.sol index 7e491e352..951cdbe56 100644 --- a/test/lit/mlirCodegen/EVM/storage-array.sol +++ b/test/lit/mlirCodegen/EVM/storage-array.sol @@ -30,6 +30,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -38,8 +45,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_65"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -47,22 +54,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_65() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_65_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_65_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_65_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_65_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/storage-fnptr.sol b/test/lit/mlirCodegen/EVM/storage-fnptr.sol index 3348f3d2e..5be4de3e9 100644 --- a/test/lit/mlirCodegen/EVM/storage-fnptr.sol +++ b/test/lit/mlirCodegen/EVM/storage-fnptr.sol @@ -28,6 +28,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -36,8 +43,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_61"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -45,22 +52,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_61() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_61_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_61_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_61_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_61_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/storage-scalar.sol b/test/lit/mlirCodegen/EVM/storage-scalar.sol index e926df717..d00942353 100644 --- a/test/lit/mlirCodegen/EVM/storage-scalar.sol +++ b/test/lit/mlirCodegen/EVM/storage-scalar.sol @@ -32,6 +32,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -40,8 +47,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_47"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -49,22 +56,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_47() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_47_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_47_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_47_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_47_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/storage-string.sol b/test/lit/mlirCodegen/EVM/storage-string.sol index d611ec400..f7a7859aa 100644 --- a/test/lit/mlirCodegen/EVM/storage-string.sol +++ b/test/lit/mlirCodegen/EVM/storage-string.sol @@ -63,6 +63,13 @@ contract Test { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -71,8 +78,8 @@ contract Test { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Test_124"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -80,22 +87,36 @@ contract Test { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @Test_124() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Test_124_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Test_124_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["Test_124_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["Test_124_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -107,6 +128,7 @@ contract Test { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c35_i256 = arith.constant 35 : i256 loc(#loc) // CHECK-NEXT: %c132_i256 = arith.constant 132 : i256 loc(#loc) // CHECK-NEXT: %c100_i256 = arith.constant 100 : i256 loc(#loc) @@ -215,63 +237,63 @@ contract Test { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %11 = arith.subi %2, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %12 = arith.cmpi slt, %11, %c32_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %12 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%41, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%45, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %13 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<2> loc(#loc1) // CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<2> -> i256 loc(#loc1) // CHECK-NEXT: %15 = arith.cmpi ugt, %14, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %15 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c34_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c34_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481748738546747006033225331_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c45888551966424197807937402689295079693071411769653575580334356259971920822272_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %16 = arith.addi %14, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %17 = arith.addi %14, %c35_i256 : i256 loc(#loc1) // CHECK-NEXT: %18 = arith.cmpi sge, %17, %2 : i256 loc(#loc1) // CHECK-NEXT: scf.if %18 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c43_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c43_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481668089093425551466635361_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c51765758038842110133680140445293787150925987327002253137507089023503727329280_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %19 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> loc(#loc1) @@ -280,58 +302,71 @@ contract Test { // CHECK-NEXT: %22 = arith.addi %21, %20 : i256 loc(#loc1) // CHECK-NEXT: %23 = arith.cmpi ugt, %22, %2 : i256 loc(#loc1) // CHECK-NEXT: scf.if %23 { -// CHECK-NEXT: %41 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.load %41 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %43 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %44 = arith.addi %42, %c4_i256 : i256 loc(#loc1) -// CHECK-NEXT: %45 = llvm.inttoptr %44 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c32_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %46 = arith.addi %42, %c36_i256 : i256 loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.load %45 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) // CHECK-NEXT: %47 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c39_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = arith.addi %42, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c3963877391197344453575983046348115674221700746820753546331534351508065746944_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %48 = arith.addi %46, %c4_i256 : i256 loc(#loc1) // CHECK-NEXT: %49 = llvm.inttoptr %48 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %50 = arith.addi %42, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: llvm.store %c32_i256, %49 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %50 = arith.addi %46, %c36_i256 : i256 loc(#loc1) // CHECK-NEXT: %51 = llvm.inttoptr %50 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %52 = llvm.inttoptr %42 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%52, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: llvm.store %c39_i256, %51 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %52 = arith.addi %46, %c68_i256 : i256 loc(#loc1) +// CHECK-NEXT: %53 = llvm.inttoptr %52 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c29517451764962235613010368778373659638394623262010481663810023216111493996921_i256, %53 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %54 = arith.addi %46, %c100_i256 : i256 loc(#loc1) +// CHECK-NEXT: %55 = llvm.inttoptr %54 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c14665530690530801964634585719976680554868009180561069516385661492758486974464_i256, %55 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %56 = llvm.inttoptr %46 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%56, %c132_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %24 = arith.addi %20, %c31_i256 : i256 loc(#loc1) // CHECK-NEXT: %25 = arith.andi %24, %c-32_i256 : i256 loc(#loc1) // CHECK-NEXT: %26 = arith.cmpi ugt, %20, %c18446744073709551615_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %26 { -// CHECK-NEXT: %41 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %42 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c65_i256, %42 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %43 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%43, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %27 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %28 = llvm.load %27 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %29 = arith.addi %25, %c63_i256 : i256 loc(#loc1) +// CHECK-NEXT: %30 = arith.andi %29, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %31 = arith.addi %28, %30 : i256 loc(#loc1) +// CHECK-NEXT: %32 = arith.cmpi ugt, %31, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %33 = arith.cmpi ult, %31, %28 : i256 loc(#loc1) +// CHECK-NEXT: %34 = arith.ori %32, %33 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %34 { +// CHECK-NEXT: %45 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %45 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %46 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %47 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%47, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) -// CHECK-NEXT: %27 = arith.addi %25, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %28 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %29 = llvm.load %28 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %30 = arith.addi %29, %27 : i256 loc(#loc1) -// CHECK-NEXT: %31 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %30, %31 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %32 = llvm.inttoptr %29 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %20, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %33 = arith.addi %29, %c32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %34 = llvm.inttoptr %33 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %35 = llvm.inttoptr %21 : i256 to !llvm.ptr<2> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%34, %35, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) -// CHECK-NEXT: %36 = arith.addi %33, %20 : i256 loc(#loc1) -// CHECK-NEXT: %37 = llvm.inttoptr %36 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c0_i256, %37 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: func.call @m_53(%29) : (i256) -> () loc(#loc1) -// CHECK-NEXT: %38 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %39 = llvm.load %38 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %40 = llvm.inttoptr %39 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%40, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %35 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %31, %35 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %36 = llvm.inttoptr %28 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %20, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %37 = arith.addi %28, %c32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %38 = llvm.inttoptr %37 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %39 = llvm.inttoptr %21 : i256 to !llvm.ptr<2> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%38, %39, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc1) +// CHECK-NEXT: %40 = arith.addi %37, %20 : i256 loc(#loc1) +// CHECK-NEXT: %41 = llvm.inttoptr %40 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %41 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: func.call @m_53(%28) : (i256) -> () loc(#loc1) +// CHECK-NEXT: %42 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %43 = llvm.load %42 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %44 = llvm.inttoptr %43 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%44, %c0_i256) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -454,8 +489,8 @@ contract Test { // CHECK-NEXT: %9 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %10 = arith.cmpi ne, %9, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %10 { -// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%28, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %30 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%30, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %11 = func.call @m2_79() : () -> i256 loc(#loc1) @@ -471,14 +506,17 @@ contract Test { // CHECK-NEXT: %20 = llvm.inttoptr %16 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %21 = llvm.inttoptr %19 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: "llvm.intr.memmove"(%20, %21, %18) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<1>, i256) -> () loc(#loc1) -// CHECK-NEXT: %22 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %18, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %23 = arith.addi %18, %c31_i256 : i256 loc(#loc1) -// CHECK-NEXT: %24 = arith.andi %23, %c-32_i256 : i256 loc(#loc1) -// CHECK-NEXT: %25 = arith.addi %16, %24 : i256 loc(#loc1) -// CHECK-NEXT: %26 = arith.subi %25, %13 : i256 loc(#loc1) -// CHECK-NEXT: %27 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%27, %26) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %22 = arith.addi %16, %18 : i256 loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c0_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %18, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = arith.addi %18, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %26 = arith.andi %25, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %27 = arith.addi %16, %26 : i256 loc(#loc1) +// CHECK-NEXT: %28 = arith.subi %27, %13 : i256 loc(#loc1) +// CHECK-NEXT: %29 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%29, %28) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: scf.yield loc(#loc1) // CHECK-NEXT: } @@ -823,9 +861,12 @@ contract Test { // CHECK-NEXT: return %19 : i256 loc(#loc15) // CHECK-NEXT: } loc(#loc13) // CHECK-NEXT: func.func @m2_79() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) // CHECK-NEXT: %c-256_i256 = arith.constant -256 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) @@ -848,51 +889,64 @@ contract Test { // CHECK-NEXT: %8 = arith.trunci %3 : i256 to i1 loc(#loc17) // CHECK-NEXT: %9 = arith.cmpi eq, %8, %7 : i1 loc(#loc17) // CHECK-NEXT: scf.if %9 { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %23 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %c34_i256, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: "llvm.intrcall"(%24, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc17) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c34_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc17) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc17) // CHECK-NEXT: } loc(#loc17) // CHECK-NEXT: %10 = arith.addi %6, %c31_i256 : i256 loc(#loc17) // CHECK-NEXT: %11 = arith.andi %10, %c-32_i256 : i256 loc(#loc17) -// CHECK-NEXT: %12 = arith.addi %11, %c32_i256 : i256 loc(#loc17) -// CHECK-NEXT: %13 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc17) -// CHECK-NEXT: %15 = arith.addi %14, %12 : i256 loc(#loc17) -// CHECK-NEXT: %16 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %15, %16 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %6, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %18 = arith.addi %14, %c32_i256 : i256 loc(#loc17) -// CHECK-NEXT: %19 = llvm.inttoptr %14 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %6, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %20 = arith.andi %1, %c1_i256 : i256 loc(#loc17) -// CHECK-NEXT: %21 = arith.cmpi eq, %20, %c0_i256 : i256 loc(#loc17) -// CHECK-NEXT: scf.if %21 { -// CHECK-NEXT: %22 = arith.andi %1, %c-256_i256 : i256 loc(#loc17) -// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %22, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc17) +// CHECK-NEXT: %14 = arith.addi %11, %c63_i256 : i256 loc(#loc17) +// CHECK-NEXT: %15 = arith.andi %14, %c-32_i256 : i256 loc(#loc17) +// CHECK-NEXT: %16 = arith.addi %13, %15 : i256 loc(#loc17) +// CHECK-NEXT: %17 = arith.cmpi ugt, %16, %c18446744073709551615_i256 : i256 loc(#loc17) +// CHECK-NEXT: %18 = arith.cmpi ult, %16, %13 : i256 loc(#loc17) +// CHECK-NEXT: %19 = arith.ori %17, %18 : i1 loc(#loc17) +// CHECK-NEXT: scf.if %19 { +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %27 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c65_i256, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %28 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: "llvm.intrcall"(%28, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc17) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc17) +// CHECK-NEXT: } loc(#loc17) +// CHECK-NEXT: %20 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %16, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %21 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %6, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %22 = arith.addi %13, %c32_i256 : i256 loc(#loc17) +// CHECK-NEXT: %23 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %6, %23 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %24 = arith.andi %1, %c1_i256 : i256 loc(#loc17) +// CHECK-NEXT: %25 = arith.cmpi eq, %24, %c0_i256 : i256 loc(#loc17) +// CHECK-NEXT: scf.if %25 { +// CHECK-NEXT: %26 = arith.andi %1, %c-256_i256 : i256 loc(#loc17) +// CHECK-NEXT: %27 = llvm.inttoptr %22 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %26, %27 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) // CHECK-NEXT: } else { -// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %c0_i256, %22 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %23 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: %24 = "llvm.intrcall"(%23, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc17) -// CHECK-NEXT: %25 = arith.index_castui %6 : i256 to index loc(#loc17) -// CHECK-NEXT: scf.for %arg0 = %c0 to %25 step %c32 { -// CHECK-NEXT: %26 = arith.index_castui %arg0 : index to i256 loc(#loc17) -// CHECK-NEXT: %27 = arith.divui %26, %c32_i256 : i256 loc(#loc17) -// CHECK-NEXT: %28 = arith.addi %24, %27 : i256 loc(#loc17) -// CHECK-NEXT: %29 = llvm.inttoptr %28 : i256 to !llvm.ptr<5> loc(#loc17) -// CHECK-NEXT: %30 = llvm.load %29 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc17) -// CHECK-NEXT: %31 = arith.addi %18, %26 : i256 loc(#loc17) -// CHECK-NEXT: %32 = llvm.inttoptr %31 : i256 to !llvm.ptr<1> loc(#loc17) -// CHECK-NEXT: llvm.store %30, %32 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %c0_i256, %26 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %27 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: %28 = "llvm.intrcall"(%27, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc17) +// CHECK-NEXT: %29 = arith.index_castui %6 : i256 to index loc(#loc17) +// CHECK-NEXT: scf.for %arg0 = %c0 to %29 step %c32 { +// CHECK-NEXT: %30 = arith.index_castui %arg0 : index to i256 loc(#loc17) +// CHECK-NEXT: %31 = arith.divui %30, %c32_i256 : i256 loc(#loc17) +// CHECK-NEXT: %32 = arith.addi %28, %31 : i256 loc(#loc17) +// CHECK-NEXT: %33 = llvm.inttoptr %32 : i256 to !llvm.ptr<5> loc(#loc17) +// CHECK-NEXT: %34 = llvm.load %33 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc17) +// CHECK-NEXT: %35 = arith.addi %22, %30 : i256 loc(#loc17) +// CHECK-NEXT: %36 = llvm.inttoptr %35 : i256 to !llvm.ptr<1> loc(#loc17) +// CHECK-NEXT: llvm.store %34, %36 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc17) // CHECK-NEXT: } loc(#loc17) // CHECK-NEXT: } loc(#loc17) -// CHECK-NEXT: return %14 : i256 loc(#loc18) +// CHECK-NEXT: return %13 : i256 loc(#loc18) // CHECK-NEXT: } loc(#loc16) // CHECK-NEXT: func.func @cs_71(%arg0: !llvm.struct<(i256, i256)> loc({{.*}}:30:14)) attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/storage-struct.sol b/test/lit/mlirCodegen/EVM/storage-struct.sol index 2b1dfa681..4d379c71c 100644 --- a/test/lit/mlirCodegen/EVM/storage-struct.sol +++ b/test/lit/mlirCodegen/EVM/storage-struct.sol @@ -98,6 +98,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -106,8 +113,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_243"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -115,22 +122,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_243() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_243_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_243_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_243_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_243_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -214,15 +235,17 @@ contract C { // CHECK-NEXT: %c256_i256 = arith.constant 256 : i256 loc(#loc) // CHECK-NEXT: %c32 = arith.constant 32 : index loc(#loc) // CHECK-NEXT: %c0 = arith.constant 0 : index loc(#loc) -// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c1 = arith.constant 1 : index loc(#loc) -// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c34_i256 = arith.constant 34 : i256 loc(#loc) -// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) -// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c127_i256 = arith.constant 127 : i256 loc(#loc) // CHECK-NEXT: %c47687202278368593055453199545051370742183790376672955679702151372887807754240_i256 = arith.constant 47687202278368593055453199545051370742183790376672955679702151372887807754240 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c9_i256 = arith.constant 9 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) @@ -324,155 +347,167 @@ contract C { // CHECK-NEXT: %75 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) // CHECK-NEXT: %76 = llvm.load %75 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc19) // CHECK-NEXT: %77 = arith.addi %76, %c64_i256 : i256 loc(#loc19) -// CHECK-NEXT: %78 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: llvm.store %77, %78 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: %79 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: llvm.store %c2_i256, %79 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: %80 = arith.addi %76, %c32_i256 : i256 loc(#loc19) -// CHECK-NEXT: %81 = llvm.inttoptr %80 : i256 to !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: llvm.store %c47687202278368593055453199545051370742183790376672955679702151372887807754240_i256, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) -// CHECK-NEXT: %82 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %83 = llvm.load %82 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %84 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) -// CHECK-NEXT: %85 = llvm.load %84 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc20) -// CHECK-NEXT: %86 = arith.shrui %85, %c1_i256 : i256 loc(#loc20) -// CHECK-NEXT: %87 = arith.andi %85, %c1_i256 : i256 loc(#loc20) -// CHECK-NEXT: %88 = arith.cmpi eq, %87, %c0_i256 : i256 loc(#loc20) -// CHECK-NEXT: %89 = arith.andi %86, %c127_i256 : i256 loc(#loc20) -// CHECK-NEXT: %90 = arith.select %88, %89, %86 : i256 loc(#loc20) -// CHECK-NEXT: %91 = arith.cmpi ult, %90, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %92 = arith.trunci %87 : i256 to i1 loc(#loc20) -// CHECK-NEXT: %93 = arith.cmpi eq, %92, %91 : i1 loc(#loc20) -// CHECK-NEXT: scf.if %93 { -// CHECK-NEXT: %128 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %129 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c34_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %130 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: "llvm.intrcall"(%130, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) +// CHECK-NEXT: %78 = arith.cmpi ugt, %77, %c18446744073709551615_i256 : i256 loc(#loc19) +// CHECK-NEXT: %79 = arith.cmpi ult, %77, %76 : i256 loc(#loc19) +// CHECK-NEXT: %80 = arith.ori %78, %79 : i1 loc(#loc19) +// CHECK-NEXT: scf.if %80 { +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %132 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c65_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %133 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: "llvm.intrcall"(%133, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc19) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc19) +// CHECK-NEXT: } loc(#loc19) +// CHECK-NEXT: %81 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %77, %81 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %82 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c2_i256, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %83 = arith.addi %76, %c32_i256 : i256 loc(#loc19) +// CHECK-NEXT: %84 = llvm.inttoptr %83 : i256 to !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: llvm.store %c47687202278368593055453199545051370742183790376672955679702151372887807754240_i256, %84 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc19) +// CHECK-NEXT: %85 = llvm.inttoptr %76 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %87 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %88 = llvm.load %87 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc20) +// CHECK-NEXT: %89 = arith.shrui %88, %c1_i256 : i256 loc(#loc20) +// CHECK-NEXT: %90 = arith.andi %88, %c1_i256 : i256 loc(#loc20) +// CHECK-NEXT: %91 = arith.cmpi eq, %90, %c0_i256 : i256 loc(#loc20) +// CHECK-NEXT: %92 = arith.andi %89, %c127_i256 : i256 loc(#loc20) +// CHECK-NEXT: %93 = arith.select %91, %92, %89 : i256 loc(#loc20) +// CHECK-NEXT: %94 = arith.cmpi ult, %93, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %95 = arith.trunci %90 : i256 to i1 loc(#loc20) +// CHECK-NEXT: %96 = arith.cmpi eq, %95, %94 : i1 loc(#loc20) +// CHECK-NEXT: scf.if %96 { +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %132 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c34_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %133 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: "llvm.intrcall"(%133, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc20) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %94 = arith.cmpi ugt, %90, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %94 { -// CHECK-NEXT: %128 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c12_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %130 = "llvm.intrcall"(%129, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc20) -// CHECK-NEXT: %131 = arith.addi %83, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: %132 = arith.divui %131, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %133 = arith.addi %130, %132 : i256 loc(#loc20) -// CHECK-NEXT: %134 = arith.cmpi ult, %83, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %135 = arith.select %134, %130, %133 : i256 loc(#loc20) -// CHECK-NEXT: %136 = arith.addi %90, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: %137 = arith.divui %136, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %138 = arith.addi %130, %137 : i256 loc(#loc20) -// CHECK-NEXT: %139 = arith.index_castui %135 : i256 to index loc(#loc20) -// CHECK-NEXT: %140 = arith.index_castui %138 : i256 to index loc(#loc20) -// CHECK-NEXT: scf.for %arg0 = %139 to %140 step %c1 { -// CHECK-NEXT: %141 = arith.index_castui %arg0 : index to i256 loc(#loc20) -// CHECK-NEXT: %142 = llvm.inttoptr %141 : i256 to !llvm.ptr<5> loc(#loc20) -// CHECK-NEXT: llvm.store %c0_i256, %142 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %97 = arith.cmpi ugt, %93, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %97 { +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c12_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %132 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %133 = "llvm.intrcall"(%132, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc20) +// CHECK-NEXT: %134 = arith.addi %86, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %135 = arith.divui %134, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %136 = arith.addi %133, %135 : i256 loc(#loc20) +// CHECK-NEXT: %137 = arith.cmpi ult, %86, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %138 = arith.select %137, %133, %136 : i256 loc(#loc20) +// CHECK-NEXT: %139 = arith.addi %93, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %140 = arith.divui %139, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %141 = arith.addi %133, %140 : i256 loc(#loc20) +// CHECK-NEXT: %142 = arith.index_castui %138 : i256 to index loc(#loc20) +// CHECK-NEXT: %143 = arith.index_castui %141 : i256 to index loc(#loc20) +// CHECK-NEXT: scf.for %arg0 = %142 to %143 step %c1 { +// CHECK-NEXT: %144 = arith.index_castui %arg0 : index to i256 loc(#loc20) +// CHECK-NEXT: %145 = llvm.inttoptr %144 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: llvm.store %c0_i256, %145 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) // CHECK-NEXT: } loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %95 = arith.cmpi ugt, %83, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %95 { -// CHECK-NEXT: %128 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: llvm.store %c12_i256, %128 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %129 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %130 = "llvm.intrcall"(%129, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc20) -// CHECK-NEXT: %131 = arith.addi %76, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %132 = arith.andi %83, %c-32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %133 = arith.index_castui %132 : i256 to index loc(#loc20) -// CHECK-NEXT: scf.for %arg0 = %c0 to %133 step %c32 { -// CHECK-NEXT: %138 = arith.index_castui %arg0 : index to i256 loc(#loc20) -// CHECK-NEXT: %139 = arith.divui %138, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %140 = arith.addi %131, %138 : i256 loc(#loc20) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %143 = arith.addi %130, %139 : i256 loc(#loc20) -// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<5> loc(#loc20) -// CHECK-NEXT: llvm.store %142, %144 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %98 = arith.cmpi ugt, %86, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %98 { +// CHECK-NEXT: %131 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: llvm.store %c12_i256, %131 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %132 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %133 = "llvm.intrcall"(%132, %c32_i256) <{id = 4085 : i32, name = "evm.sha3"}> : (!llvm.ptr<1>, i256) -> i256 loc(#loc20) +// CHECK-NEXT: %134 = arith.addi %76, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %135 = arith.andi %86, %c-32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %136 = arith.index_castui %135 : i256 to index loc(#loc20) +// CHECK-NEXT: scf.for %arg0 = %c0 to %136 step %c32 { +// CHECK-NEXT: %141 = arith.index_castui %arg0 : index to i256 loc(#loc20) +// CHECK-NEXT: %142 = arith.divui %141, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %143 = arith.addi %134, %141 : i256 loc(#loc20) +// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %145 = llvm.load %144 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %146 = arith.addi %133, %142 : i256 loc(#loc20) +// CHECK-NEXT: %147 = llvm.inttoptr %146 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: llvm.store %145, %147 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %134 = arith.cmpi ult, %132, %83 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %134 { -// CHECK-NEXT: %138 = arith.andi %83, %c31_i256 : i256 loc(#loc20) -// CHECK-NEXT: %139 = arith.divui %132, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %140 = arith.addi %131, %132 : i256 loc(#loc20) -// CHECK-NEXT: %141 = llvm.inttoptr %140 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %142 = llvm.load %141 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %143 = arith.muli %138, %c8_i256 : i256 loc(#loc20) -// CHECK-NEXT: %144 = arith.subi %c256_i256, %143 : i256 loc(#loc20) -// CHECK-NEXT: %145 = arith.shli %c-1_i256, %144 : i256 loc(#loc20) -// CHECK-NEXT: %146 = arith.andi %142, %145 : i256 loc(#loc20) -// CHECK-NEXT: %147 = arith.addi %130, %139 : i256 loc(#loc20) -// CHECK-NEXT: %148 = llvm.inttoptr %147 : i256 to !llvm.ptr<5> loc(#loc20) -// CHECK-NEXT: llvm.store %146, %148 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %137 = arith.cmpi ult, %135, %86 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %137 { +// CHECK-NEXT: %141 = arith.andi %86, %c31_i256 : i256 loc(#loc20) +// CHECK-NEXT: %142 = arith.divui %135, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %143 = arith.addi %134, %135 : i256 loc(#loc20) +// CHECK-NEXT: %144 = llvm.inttoptr %143 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %145 = llvm.load %144 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %146 = arith.muli %141, %c8_i256 : i256 loc(#loc20) +// CHECK-NEXT: %147 = arith.subi %c256_i256, %146 : i256 loc(#loc20) +// CHECK-NEXT: %148 = arith.shli %c-1_i256, %147 : i256 loc(#loc20) +// CHECK-NEXT: %149 = arith.andi %145, %148 : i256 loc(#loc20) +// CHECK-NEXT: %150 = arith.addi %133, %142 : i256 loc(#loc20) +// CHECK-NEXT: %151 = llvm.inttoptr %150 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: llvm.store %149, %151 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %135 = arith.muli %83, %c2_i256 : i256 loc(#loc20) -// CHECK-NEXT: %136 = arith.ori %135, %c1_i256 : i256 loc(#loc20) -// CHECK-NEXT: %137 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) -// CHECK-NEXT: llvm.store %136, %137 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %138 = arith.muli %86, %c2_i256 : i256 loc(#loc20) +// CHECK-NEXT: %139 = arith.ori %138, %c1_i256 : i256 loc(#loc20) +// CHECK-NEXT: %140 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: llvm.store %139, %140 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) // CHECK-NEXT: } else { -// CHECK-NEXT: %128 = arith.cmpi ne, %83, %c0_i256 : i256 loc(#loc20) -// CHECK-NEXT: scf.if %128 { -// CHECK-NEXT: %129 = arith.addi %76, %c32_i256 : i256 loc(#loc20) -// CHECK-NEXT: %130 = llvm.inttoptr %129 : i256 to !llvm.ptr<1> loc(#loc20) -// CHECK-NEXT: %131 = llvm.load %130 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) -// CHECK-NEXT: %132 = arith.muli %83, %c8_i256 : i256 loc(#loc20) -// CHECK-NEXT: %133 = arith.subi %c256_i256, %132 : i256 loc(#loc20) -// CHECK-NEXT: %134 = arith.shli %c-1_i256, %133 : i256 loc(#loc20) -// CHECK-NEXT: %135 = arith.andi %131, %134 : i256 loc(#loc20) -// CHECK-NEXT: %136 = arith.muli %83, %c2_i256 : i256 loc(#loc20) -// CHECK-NEXT: %137 = arith.ori %135, %136 : i256 loc(#loc20) -// CHECK-NEXT: %138 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) -// CHECK-NEXT: llvm.store %137, %138 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %131 = arith.cmpi ne, %86, %c0_i256 : i256 loc(#loc20) +// CHECK-NEXT: scf.if %131 { +// CHECK-NEXT: %132 = arith.addi %76, %c32_i256 : i256 loc(#loc20) +// CHECK-NEXT: %133 = llvm.inttoptr %132 : i256 to !llvm.ptr<1> loc(#loc20) +// CHECK-NEXT: %134 = llvm.load %133 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc20) +// CHECK-NEXT: %135 = arith.muli %86, %c8_i256 : i256 loc(#loc20) +// CHECK-NEXT: %136 = arith.subi %c256_i256, %135 : i256 loc(#loc20) +// CHECK-NEXT: %137 = arith.shli %c-1_i256, %136 : i256 loc(#loc20) +// CHECK-NEXT: %138 = arith.andi %134, %137 : i256 loc(#loc20) +// CHECK-NEXT: %139 = arith.muli %86, %c2_i256 : i256 loc(#loc20) +// CHECK-NEXT: %140 = arith.ori %138, %139 : i256 loc(#loc20) +// CHECK-NEXT: %141 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: llvm.store %140, %141 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) // CHECK-NEXT: } else { -// CHECK-NEXT: %129 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) -// CHECK-NEXT: llvm.store %c0_i256, %129 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: %132 = llvm.inttoptr %c12_i256 : i256 to !llvm.ptr<5> loc(#loc20) +// CHECK-NEXT: llvm.store %c0_i256, %132 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc20) // CHECK-NEXT: } loc(#loc20) // CHECK-NEXT: } loc(#loc20) -// CHECK-NEXT: %96 = llvm.inttoptr %c13_i256 : i256 to !llvm.ptr<5> loc(#loc21) -// CHECK-NEXT: llvm.store %c300_i256, %96 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc21) -// CHECK-NEXT: %97 = llvm.inttoptr %c13_i256 : i256 to !llvm.ptr<5> loc(#loc22) -// CHECK-NEXT: %98 = llvm.load %97 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc22) -// CHECK-NEXT: %99 = llvm.inttoptr %c10_i256 : i256 to !llvm.ptr<5> loc(#loc23) -// CHECK-NEXT: llvm.store %98, %99 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc23) -// CHECK-NEXT: %100 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc24) -// CHECK-NEXT: %101 = llvm.load %100 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc24) -// CHECK-NEXT: %102 = arith.andi %101, %c-256_i256 : i256 loc(#loc24) -// CHECK-NEXT: %103 = arith.ori %102, %c1_i256 : i256 loc(#loc24) -// CHECK-NEXT: %104 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc24) -// CHECK-NEXT: llvm.store %103, %104 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc24) -// CHECK-NEXT: %105 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc25) -// CHECK-NEXT: %106 = llvm.load %105 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc25) -// CHECK-NEXT: %107 = arith.andi %106, %c-65281_i256 : i256 loc(#loc25) -// CHECK-NEXT: %108 = arith.ori %107, %c512_i256 : i256 loc(#loc25) -// CHECK-NEXT: %109 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc25) -// CHECK-NEXT: llvm.store %108, %109 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc25) -// CHECK-NEXT: %110 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc26) -// CHECK-NEXT: %111 = llvm.load %110 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc26) -// CHECK-NEXT: %112 = arith.andi %111, %c-16711681_i256 : i256 loc(#loc26) -// CHECK-NEXT: %113 = arith.ori %112, %c196608_i256 : i256 loc(#loc26) -// CHECK-NEXT: %114 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc26) -// CHECK-NEXT: llvm.store %113, %114 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc26) -// CHECK-NEXT: %115 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc27) -// CHECK-NEXT: %116 = llvm.load %115 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc27) -// CHECK-NEXT: %117 = arith.andi %116, %c-4278190081_i256 : i256 loc(#loc27) -// CHECK-NEXT: %118 = arith.ori %117, %c67108864_i256 : i256 loc(#loc27) -// CHECK-NEXT: %119 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc27) -// CHECK-NEXT: llvm.store %118, %119 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc27) -// CHECK-NEXT: %120 = llvm.inttoptr %c18_i256 : i256 to !llvm.ptr<5> loc(#loc28) -// CHECK-NEXT: llvm.store %c43690_i256, %120 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc28) -// CHECK-NEXT: %121 = llvm.inttoptr %c15_i256 : i256 to !llvm.ptr<5> loc(#loc29) -// CHECK-NEXT: llvm.store %c48059_i256, %121 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc29) -// CHECK-NEXT: %122 = llvm.inttoptr %c15_i256 : i256 to !llvm.ptr<5> loc(#loc30) -// CHECK-NEXT: %123 = llvm.load %122 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc30) -// CHECK-NEXT: %124 = llvm.inttoptr %c16_i256 : i256 to !llvm.ptr<5> loc(#loc31) -// CHECK-NEXT: llvm.store %123, %124 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc31) -// CHECK-NEXT: %125 = llvm.inttoptr %c18_i256 : i256 to !llvm.ptr<5> loc(#loc32) -// CHECK-NEXT: %126 = llvm.load %125 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc32) -// CHECK-NEXT: %127 = llvm.inttoptr %c17_i256 : i256 to !llvm.ptr<5> loc(#loc33) -// CHECK-NEXT: llvm.store %126, %127 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc33) +// CHECK-NEXT: %99 = llvm.inttoptr %c13_i256 : i256 to !llvm.ptr<5> loc(#loc21) +// CHECK-NEXT: llvm.store %c300_i256, %99 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc21) +// CHECK-NEXT: %100 = llvm.inttoptr %c13_i256 : i256 to !llvm.ptr<5> loc(#loc22) +// CHECK-NEXT: %101 = llvm.load %100 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc22) +// CHECK-NEXT: %102 = llvm.inttoptr %c10_i256 : i256 to !llvm.ptr<5> loc(#loc23) +// CHECK-NEXT: llvm.store %101, %102 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc23) +// CHECK-NEXT: %103 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc24) +// CHECK-NEXT: %104 = llvm.load %103 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc24) +// CHECK-NEXT: %105 = arith.andi %104, %c-256_i256 : i256 loc(#loc24) +// CHECK-NEXT: %106 = arith.ori %105, %c1_i256 : i256 loc(#loc24) +// CHECK-NEXT: %107 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc24) +// CHECK-NEXT: llvm.store %106, %107 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc24) +// CHECK-NEXT: %108 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc25) +// CHECK-NEXT: %109 = llvm.load %108 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc25) +// CHECK-NEXT: %110 = arith.andi %109, %c-65281_i256 : i256 loc(#loc25) +// CHECK-NEXT: %111 = arith.ori %110, %c512_i256 : i256 loc(#loc25) +// CHECK-NEXT: %112 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc25) +// CHECK-NEXT: llvm.store %111, %112 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc25) +// CHECK-NEXT: %113 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc26) +// CHECK-NEXT: %114 = llvm.load %113 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc26) +// CHECK-NEXT: %115 = arith.andi %114, %c-16711681_i256 : i256 loc(#loc26) +// CHECK-NEXT: %116 = arith.ori %115, %c196608_i256 : i256 loc(#loc26) +// CHECK-NEXT: %117 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc26) +// CHECK-NEXT: llvm.store %116, %117 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc26) +// CHECK-NEXT: %118 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: %119 = llvm.load %118 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc27) +// CHECK-NEXT: %120 = arith.andi %119, %c-4278190081_i256 : i256 loc(#loc27) +// CHECK-NEXT: %121 = arith.ori %120, %c67108864_i256 : i256 loc(#loc27) +// CHECK-NEXT: %122 = llvm.inttoptr %c14_i256 : i256 to !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: llvm.store %121, %122 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc27) +// CHECK-NEXT: %123 = llvm.inttoptr %c18_i256 : i256 to !llvm.ptr<5> loc(#loc28) +// CHECK-NEXT: llvm.store %c43690_i256, %123 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc28) +// CHECK-NEXT: %124 = llvm.inttoptr %c15_i256 : i256 to !llvm.ptr<5> loc(#loc29) +// CHECK-NEXT: llvm.store %c48059_i256, %124 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc29) +// CHECK-NEXT: %125 = llvm.inttoptr %c15_i256 : i256 to !llvm.ptr<5> loc(#loc30) +// CHECK-NEXT: %126 = llvm.load %125 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc30) +// CHECK-NEXT: %127 = llvm.inttoptr %c16_i256 : i256 to !llvm.ptr<5> loc(#loc31) +// CHECK-NEXT: llvm.store %126, %127 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc31) +// CHECK-NEXT: %128 = llvm.inttoptr %c18_i256 : i256 to !llvm.ptr<5> loc(#loc32) +// CHECK-NEXT: %129 = llvm.load %128 {alignment = 1 : i64} : !llvm.ptr<5> -> i256 loc(#loc32) +// CHECK-NEXT: %130 = llvm.inttoptr %c17_i256 : i256 to !llvm.ptr<5> loc(#loc33) +// CHECK-NEXT: llvm.store %129, %130 {alignment = 1 : i64} : i256, !llvm.ptr<5> loc(#loc33) // CHECK-NEXT: return loc(#loc2) // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: } loc(#loc1) diff --git a/test/lit/mlirCodegen/EVM/struct.sol b/test/lit/mlirCodegen/EVM/struct.sol index ee403d489..1f6b67e06 100644 --- a/test/lit/mlirCodegen/EVM/struct.sol +++ b/test/lit/mlirCodegen/EVM/struct.sol @@ -56,28 +56,57 @@ function malloc() { // CHECK-NEXT: } loc(#loc2) // CHECK-NEXT: func.func @malloc_32() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c96_i256 = arith.constant 96 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc7) // CHECK-NEXT: %0 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc7) // CHECK-NEXT: %1 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) // CHECK-NEXT: %2 = llvm.load %1 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc7) // CHECK-NEXT: %3 = arith.addi %2, %c64_i256 : i256 loc(#loc7) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: llvm.store %3, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %5 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: llvm.store %c0_i256, %5 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc7) -// CHECK-NEXT: %8 = arith.addi %7, %c96_i256 : i256 loc(#loc7) +// CHECK-NEXT: %4 = arith.cmpi ugt, %3, %c18446744073709551615_i256 : i256 loc(#loc7) +// CHECK-NEXT: %5 = arith.cmpi ult, %3, %2 : i256 loc(#loc7) +// CHECK-NEXT: %6 = arith.ori %4, %5 : i1 loc(#loc7) +// CHECK-NEXT: scf.if %6 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc7) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc7) +// CHECK-NEXT: } loc(#loc7) +// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %3, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %8 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %c0_i256, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) // CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %10 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc7) -// CHECK-NEXT: %11 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<2> loc(#loc7) -// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc7) -// CHECK-NEXT: %13 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc7) -// CHECK-NEXT: llvm.store %7, %13 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %10 = llvm.load %9 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc7) +// CHECK-NEXT: %11 = arith.addi %10, %c96_i256 : i256 loc(#loc7) +// CHECK-NEXT: %12 = arith.cmpi ugt, %11, %c18446744073709551615_i256 : i256 loc(#loc7) +// CHECK-NEXT: %13 = arith.cmpi ult, %11, %10 : i256 loc(#loc7) +// CHECK-NEXT: %14 = arith.ori %12, %13 : i1 loc(#loc7) +// CHECK-NEXT: scf.if %14 { +// CHECK-NEXT: %20 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %21 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %c65_i256, %21 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %22 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: "llvm.intrcall"(%22, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc7) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc7) +// CHECK-NEXT: } loc(#loc7) +// CHECK-NEXT: %15 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %11, %15 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %16 = "llvm.intrcall"() <{id = 4038 : i32, name = "evm.calldatasize"}> : () -> i256 loc(#loc7) +// CHECK-NEXT: %17 = llvm.inttoptr %10 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: %18 = llvm.inttoptr %16 : i256 to !llvm.ptr<2> loc(#loc7) +// CHECK-NEXT: "llvm.intr.memcpy"(%17, %18, %c96_i256) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<2>, i256) -> () loc(#loc7) +// CHECK-NEXT: %19 = llvm.inttoptr %2 : i256 to !llvm.ptr<1> loc(#loc7) +// CHECK-NEXT: llvm.store %10, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc7) // CHECK-NEXT: llvm.store %2, %0 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc7) // CHECK-NEXT: return loc(#loc6) // CHECK-NEXT: } loc(#loc6) diff --git a/test/lit/mlirCodegen/EVM/this.sol b/test/lit/mlirCodegen/EVM/this.sol index 3646bccf0..b8ac1a27a 100644 --- a/test/lit/mlirCodegen/EVM/this.sol +++ b/test/lit/mlirCodegen/EVM/this.sol @@ -14,6 +14,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -22,8 +29,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_14"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -31,22 +38,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_14() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_14_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_14_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_14_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_14_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/transient.sol b/test/lit/mlirCodegen/EVM/transient.sol index 6ed6da48f..2b82024a1 100644 --- a/test/lit/mlirCodegen/EVM/transient.sol +++ b/test/lit/mlirCodegen/EVM/transient.sol @@ -33,6 +33,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -41,8 +48,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_84"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -50,22 +57,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_84() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_84_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_84_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_84_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_84_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -80,10 +101,10 @@ contract C { // CHECK-NEXT: %c192_i256 = arith.constant 192 : i256 loc(#loc) // CHECK-NEXT: %c160_i256 = arith.constant 160 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) -// CHECK-NEXT: %c-26959946667150639794667015087019630673637144422540572481103610249216_i256 = arith.constant -26959946667150639794667015087019630673637144422540572481103610249216 : i256 loc(#loc) // CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) // CHECK-NEXT: %c33_i256 = arith.constant 33 : i256 loc(#loc) // CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c-26959946667150639794667015087019630673637144422540572481103610249216_i256 = arith.constant -26959946667150639794667015087019630673637144422540572481103610249216 : i256 loc(#loc) // CHECK-NEXT: %c2_i256 = arith.constant 2 : i256 loc(#loc) // CHECK-NEXT: %c1461501637330902918203684832716283019655932542975_i256 = arith.constant 1461501637330902918203684832716283019655932542975 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) @@ -141,11 +162,7 @@ contract C { // CHECK-NEXT: %22 = arith.cmpi ugt, %21, %c2_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %22 { // CHECK-NEXT: %46 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %46 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %47 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %c33_i256, %47 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %48 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%48, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%46, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %23:7 = func.call @test_83(%13, %18, %21) : (i256, i256, i256) -> (i256, i8, i256, i256, i8, i256, i1) loc(#loc1) diff --git a/test/lit/mlirCodegen/EVM/try.sol b/test/lit/mlirCodegen/EVM/try.sol index d30635adf..3bd28b453 100644 --- a/test/lit/mlirCodegen/EVM/try.sol +++ b/test/lit/mlirCodegen/EVM/try.sol @@ -22,6 +22,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -30,8 +37,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_78"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -39,22 +46,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_78() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_78_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_78_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_78_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_78_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) @@ -119,7 +140,7 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: func.func @f_77(%arg0: i256 loc({{.*}}:3:13)) -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c27_i256 = arith.constant 27 : i256 loc(#loc) // CHECK-NEXT: %c-34435155370463444793260793355178157075203752403645521721995013737368954863616_i256 = arith.constant -34435155370463444793260793355178157075203752403645521721995013737368954863616 : i256 loc(#loc) // CHECK-NEXT: %c68_i256 = arith.constant 68 : i256 loc(#loc) // CHECK-NEXT: %false = arith.constant false loc(#loc) @@ -127,6 +148,12 @@ contract C { // CHECK-NEXT: %c3_i256 = arith.constant 3 : i256 loc(#loc) // CHECK-NEXT: %true = arith.constant true loc(#loc) // CHECK-NEXT: %0 = llvm.mlir.undef : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) // CHECK-NEXT: %c224_i256 = arith.constant 224 : i256 loc(#loc) @@ -152,31 +179,57 @@ contract C { // CHECK-NEXT: %13 = "llvm.intrcall"(%5, %3, %c0_i256, %11, %c36_i256, %12, %c32_i256) <{id = 4035 : i32, name = "evm.call"}> : (i256, i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc4) // CHECK-NEXT: %14 = arith.cmpi ne, %13, %c0_i256 : i256 loc(#loc4) // CHECK-NEXT: %15 = scf.if %14 -> (i256) { -// CHECK-NEXT: %89 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc4) -// CHECK-NEXT: %90 = arith.cmpi ult, %89, %c32_i256 : i256 loc(#loc4) -// CHECK-NEXT: %91 = scf.if %90 -> (i256) { -// CHECK-NEXT: %96 = arith.addi %7, %89 : i256 loc(#loc4) -// CHECK-NEXT: %97 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: llvm.store %96, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %98 = arith.addi %7, %89 : i256 loc(#loc4) -// CHECK-NEXT: scf.yield %98 : i256 loc(#loc4) +// CHECK-NEXT: %94 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc4) +// CHECK-NEXT: %95 = arith.cmpi ult, %94, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %96 = scf.if %95 -> (i256) { +// CHECK-NEXT: %101 = arith.addi %94, %c31_i256 : i256 loc(#loc4) +// CHECK-NEXT: %102 = arith.andi %101, %c-32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %103 = arith.addi %7, %102 : i256 loc(#loc4) +// CHECK-NEXT: %104 = arith.cmpi ugt, %103, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %105 = arith.cmpi ult, %103, %7 : i256 loc(#loc4) +// CHECK-NEXT: %106 = arith.ori %104, %105 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %106 { +// CHECK-NEXT: %109 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %110 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %110 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %111 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%111, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %107 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %103, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %108 = arith.addi %7, %94 : i256 loc(#loc4) +// CHECK-NEXT: scf.yield %108 : i256 loc(#loc4) // CHECK-NEXT: } else { -// CHECK-NEXT: %96 = arith.addi %7, %c32_i256 : i256 loc(#loc4) -// CHECK-NEXT: %97 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: llvm.store %96, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %98 = arith.addi %7, %c32_i256 : i256 loc(#loc4) -// CHECK-NEXT: scf.yield %98 : i256 loc(#loc4) +// CHECK-NEXT: %101 = arith.addi %7, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: %102 = arith.cmpi ugt, %101, %c18446744073709551615_i256 : i256 loc(#loc4) +// CHECK-NEXT: %103 = arith.cmpi ult, %101, %7 : i256 loc(#loc4) +// CHECK-NEXT: %104 = arith.ori %102, %103 : i1 loc(#loc4) +// CHECK-NEXT: scf.if %104 { +// CHECK-NEXT: %107 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %108 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %c65_i256, %108 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %109 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%109, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) +// CHECK-NEXT: } loc(#loc4) +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: llvm.store %101, %105 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %106 = arith.addi %7, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: scf.yield %106 : i256 loc(#loc4) // CHECK-NEXT: } loc(#loc4) -// CHECK-NEXT: %92 = arith.subi %91, %7 : i256 loc(#loc4) -// CHECK-NEXT: %93 = arith.cmpi slt, %92, %c32_i256 : i256 loc(#loc4) -// CHECK-NEXT: scf.if %93 { -// CHECK-NEXT: %96 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: "llvm.intrcall"(%96, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) +// CHECK-NEXT: %97 = arith.subi %96, %7 : i256 loc(#loc4) +// CHECK-NEXT: %98 = arith.cmpi slt, %97, %c32_i256 : i256 loc(#loc4) +// CHECK-NEXT: scf.if %98 { +// CHECK-NEXT: %101 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: "llvm.intrcall"(%101, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc4) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc4) // CHECK-NEXT: } loc(#loc4) -// CHECK-NEXT: %94 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc4) -// CHECK-NEXT: %95 = llvm.load %94 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc4) -// CHECK-NEXT: scf.yield %95 : i256 loc(#loc4) +// CHECK-NEXT: %99 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc4) +// CHECK-NEXT: %100 = llvm.load %99 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc4) +// CHECK-NEXT: scf.yield %100 : i256 loc(#loc4) // CHECK-NEXT: } else { // CHECK-NEXT: scf.yield %0 : i256 loc(#loc4) // CHECK-NEXT: } loc(#loc4) @@ -252,31 +305,57 @@ contract C { // CHECK-NEXT: %53 = "llvm.intrcall"(%45, %43, %c0_i256, %51, %c36_i256, %52, %c32_i256) <{id = 4035 : i32, name = "evm.call"}> : (i256, i256, i256, !llvm.ptr<1>, i256, !llvm.ptr<1>, i256) -> i256 loc(#loc15) // CHECK-NEXT: %54 = arith.cmpi ne, %53, %c0_i256 : i256 loc(#loc15) // CHECK-NEXT: %55 = scf.if %54 -> (i256) { -// CHECK-NEXT: %89 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc15) -// CHECK-NEXT: %90 = arith.cmpi ult, %89, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %91 = scf.if %90 -> (i256) { -// CHECK-NEXT: %96 = arith.addi %47, %89 : i256 loc(#loc15) -// CHECK-NEXT: %97 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %96, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %98 = arith.addi %47, %89 : i256 loc(#loc15) -// CHECK-NEXT: scf.yield %98 : i256 loc(#loc15) +// CHECK-NEXT: %94 = "llvm.intrcall"() <{id = 4079 : i32, name = "evm.returndatasize"}> : () -> i256 loc(#loc15) +// CHECK-NEXT: %95 = arith.cmpi ult, %94, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %96 = scf.if %95 -> (i256) { +// CHECK-NEXT: %101 = arith.addi %94, %c31_i256 : i256 loc(#loc15) +// CHECK-NEXT: %102 = arith.andi %101, %c-32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %103 = arith.addi %47, %102 : i256 loc(#loc15) +// CHECK-NEXT: %104 = arith.cmpi ugt, %103, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: %105 = arith.cmpi ult, %103, %47 : i256 loc(#loc15) +// CHECK-NEXT: %106 = arith.ori %104, %105 : i1 loc(#loc15) +// CHECK-NEXT: scf.if %106 { +// CHECK-NEXT: %109 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %109 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %110 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %110 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %111 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%111, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %107 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %103, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %108 = arith.addi %47, %94 : i256 loc(#loc15) +// CHECK-NEXT: scf.yield %108 : i256 loc(#loc15) // CHECK-NEXT: } else { -// CHECK-NEXT: %96 = arith.addi %47, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: %97 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: llvm.store %96, %97 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %98 = arith.addi %47, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.yield %98 : i256 loc(#loc15) +// CHECK-NEXT: %101 = arith.addi %47, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: %102 = arith.cmpi ugt, %101, %c18446744073709551615_i256 : i256 loc(#loc15) +// CHECK-NEXT: %103 = arith.cmpi ult, %101, %47 : i256 loc(#loc15) +// CHECK-NEXT: %104 = arith.ori %102, %103 : i1 loc(#loc15) +// CHECK-NEXT: scf.if %104 { +// CHECK-NEXT: %107 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %107 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %108 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %c65_i256, %108 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %109 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%109, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) +// CHECK-NEXT: } loc(#loc15) +// CHECK-NEXT: %105 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: llvm.store %101, %105 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %106 = arith.addi %47, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.yield %106 : i256 loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %92 = arith.subi %91, %47 : i256 loc(#loc15) -// CHECK-NEXT: %93 = arith.cmpi slt, %92, %c32_i256 : i256 loc(#loc15) -// CHECK-NEXT: scf.if %93 { -// CHECK-NEXT: %96 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: "llvm.intrcall"(%96, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) +// CHECK-NEXT: %97 = arith.subi %96, %47 : i256 loc(#loc15) +// CHECK-NEXT: %98 = arith.cmpi slt, %97, %c32_i256 : i256 loc(#loc15) +// CHECK-NEXT: scf.if %98 { +// CHECK-NEXT: %101 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: "llvm.intrcall"(%101, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc15) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc15) // CHECK-NEXT: } loc(#loc15) -// CHECK-NEXT: %94 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc15) -// CHECK-NEXT: %95 = llvm.load %94 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) -// CHECK-NEXT: scf.yield %95 : i256 loc(#loc15) +// CHECK-NEXT: %99 = llvm.inttoptr %47 : i256 to !llvm.ptr<1> loc(#loc15) +// CHECK-NEXT: %100 = llvm.load %99 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc15) +// CHECK-NEXT: scf.yield %100 : i256 loc(#loc15) // CHECK-NEXT: } else { // CHECK-NEXT: scf.yield %0 : i256 loc(#loc15) // CHECK-NEXT: } loc(#loc15) @@ -323,31 +402,45 @@ contract C { // CHECK-NEXT: %73 = arith.subi %57, %c4_i256 : i256 loc(#loc22) // CHECK-NEXT: %74 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc22) // CHECK-NEXT: %75 = llvm.load %74 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc22) -// CHECK-NEXT: %76 = arith.addi %75, %73 : i256 loc(#loc22) -// CHECK-NEXT: %77 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc22) -// CHECK-NEXT: llvm.store %76, %77 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) -// CHECK-NEXT: %78 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc22) -// CHECK-NEXT: %79 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<3> loc(#loc22) -// CHECK-NEXT: "llvm.intr.memcpy"(%78, %79, %73) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc22) -// CHECK-NEXT: %80 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc22) -// CHECK-NEXT: %81 = llvm.load %80 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc22) -// CHECK-NEXT: %82 = arith.addi %75, %81 : i256 loc(#loc22) -// CHECK-NEXT: %83 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc22) -// CHECK-NEXT: llvm.store %82, %83 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc17) +// CHECK-NEXT: %76 = arith.addi %57, %c27_i256 : i256 loc(#loc22) +// CHECK-NEXT: %77 = arith.andi %76, %c-32_i256 : i256 loc(#loc22) +// CHECK-NEXT: %78 = arith.addi %75, %77 : i256 loc(#loc22) +// CHECK-NEXT: %79 = arith.cmpi ugt, %78, %c18446744073709551615_i256 : i256 loc(#loc22) +// CHECK-NEXT: %80 = arith.cmpi ult, %78, %75 : i256 loc(#loc22) +// CHECK-NEXT: %81 = arith.ori %79, %80 : i1 loc(#loc22) +// CHECK-NEXT: scf.if %81 { +// CHECK-NEXT: %94 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %94 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %95 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %c65_i256, %95 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %96 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: "llvm.intrcall"(%96, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc22) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc22) +// CHECK-NEXT: } loc(#loc22) +// CHECK-NEXT: %82 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: llvm.store %78, %82 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %83 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %84 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<3> loc(#loc22) +// CHECK-NEXT: "llvm.intr.memcpy"(%83, %84, %73) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<3>, i256) -> () loc(#loc22) +// CHECK-NEXT: %85 = llvm.inttoptr %75 : i256 to !llvm.ptr<1> loc(#loc22) +// CHECK-NEXT: %86 = llvm.load %85 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc22) +// CHECK-NEXT: %87 = arith.addi %75, %86 : i256 loc(#loc22) +// CHECK-NEXT: %88 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc22) +// CHECK-NEXT: llvm.store %87, %88 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc17) // CHECK-NEXT: cf.br ^bb15 loc(#loc17) // CHECK-NEXT: ^bb15: // 6 preds: ^bb9, ^bb10, ^bb11, ^bb12, ^bb13, ^bb14 -// CHECK-NEXT: %84 = llvm.load %56 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc17) -// CHECK-NEXT: cf.cond_br %84, ^bb16, ^bb18 loc(#loc17) +// CHECK-NEXT: %89 = llvm.load %56 {alignment = 32 : i64} : !llvm.ptr -> i1 loc(#loc17) +// CHECK-NEXT: cf.cond_br %89, ^bb16, ^bb18 loc(#loc17) // CHECK-NEXT: ^bb16: // pred: ^bb15 -// CHECK-NEXT: %85 = call @f_77(%c0_i256) : (i256) -> i256 loc(#loc23) -// CHECK-NEXT: llvm.store %85, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc24) +// CHECK-NEXT: %90 = call @f_77(%c0_i256) : (i256) -> i256 loc(#loc23) +// CHECK-NEXT: llvm.store %90, %1 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc24) // CHECK-NEXT: cf.br ^bb18 loc(#loc17) // CHECK-NEXT: ^bb17: // pred: ^bb8 -// CHECK-NEXT: %86 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc25) -// CHECK-NEXT: llvm.store %55, %86 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc25) -// CHECK-NEXT: %87 = llvm.load %86 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc26) -// CHECK-NEXT: %88 = call @f_77(%87) : (i256) -> i256 loc(#loc27) -// CHECK-NEXT: llvm.store %88, %86 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc28) +// CHECK-NEXT: %91 = llvm.alloca %c1_i256 x i256 : (i256) -> !llvm.ptr loc(#loc25) +// CHECK-NEXT: llvm.store %55, %91 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc25) +// CHECK-NEXT: %92 = llvm.load %91 {alignment = 32 : i64} : !llvm.ptr -> i256 loc(#loc26) +// CHECK-NEXT: %93 = call @f_77(%92) : (i256) -> i256 loc(#loc27) +// CHECK-NEXT: llvm.store %93, %91 {alignment = 32 : i64} : i256, !llvm.ptr loc(#loc28) // CHECK-NEXT: cf.br ^bb18 loc(#loc17) // CHECK-NEXT: ^bb18: // 3 preds: ^bb15, ^bb16, ^bb17 // CHECK-NEXT: return %c0_i256 : i256 loc(#loc29) diff --git a/test/lit/mlirCodegen/EVM/tx-block-props.sol b/test/lit/mlirCodegen/EVM/tx-block-props.sol index 5a89b17b6..6b36980e6 100644 --- a/test/lit/mlirCodegen/EVM/tx-block-props.sol +++ b/test/lit/mlirCodegen/EVM/tx-block-props.sol @@ -25,6 +25,13 @@ contract C { // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -33,8 +40,8 @@ contract C { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_136"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -42,22 +49,36 @@ contract C { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_136() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_136_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_136_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_136_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_136_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) diff --git a/test/lit/mlirCodegen/EVM/type-name.sol b/test/lit/mlirCodegen/EVM/type-name.sol index fad68b3ae..18dc36f96 100644 --- a/test/lit/mlirCodegen/EVM/type-name.sol +++ b/test/lit/mlirCodegen/EVM/type-name.sol @@ -24,10 +24,14 @@ function name_interface() pure returns (string memory) { // NOTE: Assertions have been autogenerated by test/updFileCheckTest.py // CHECK: #Osaka = #sol // CHECK-NEXT: module @C_9 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { -// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: llvm.unreachable loc(#loc1) -// CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -36,8 +40,8 @@ function name_interface() pure returns (string memory) { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -45,74 +49,145 @@ function name_interface() pure returns (string memory) { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @C_9() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_9_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["C_9_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["C_9_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc2) +// CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @name_contract_20() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c30304960855078848021012718732742538383473003799210616369701789564571014397952_i256 = arith.constant 30304960855078848021012718732742538383473003799210616369701789564571014397952 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) -// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) -// CHECK-NEXT: %2 = arith.addi %1, %c64_i256 : i256 loc(#loc3) -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %2, %3 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %4 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %c1_i256, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %5 = arith.addi %1, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %6 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %c30304960855078848021012718732742538383473003799210616369701789564571014397952_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) +// CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: %2 = arith.addi %1, %c64_i256 : i256 loc(#loc2) +// CHECK-NEXT: %3 = arith.cmpi ugt, %2, %c18446744073709551615_i256 : i256 loc(#loc2) +// CHECK-NEXT: %4 = arith.cmpi ult, %2, %1 : i256 loc(#loc2) +// CHECK-NEXT: %5 = arith.ori %3, %4 : i1 loc(#loc2) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %11 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c65_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%12, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %2, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %7 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c1_i256, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c30304960855078848021012718732742538383473003799210616369701789564571014397952_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) // CHECK-NEXT: return %1 : i256 loc(#loc4) -// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: } loc(#loc3) // CHECK-NEXT: func.func @name_abstract_31() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c29400335157912315244266070412362164103369332044010299463143527189509193072640_i256 = arith.constant 29400335157912315244266070412362164103369332044010299463143527189509193072640 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc6) // CHECK-NEXT: %2 = arith.addi %1, %c64_i256 : i256 loc(#loc6) -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: llvm.store %2, %3 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %4 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: llvm.store %c1_i256, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %5 = arith.addi %1, %c32_i256 : i256 loc(#loc6) -// CHECK-NEXT: %6 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: llvm.store %c29400335157912315244266070412362164103369332044010299463143527189509193072640_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %3 = arith.cmpi ugt, %2, %c18446744073709551615_i256 : i256 loc(#loc6) +// CHECK-NEXT: %4 = arith.cmpi ult, %2, %1 : i256 loc(#loc6) +// CHECK-NEXT: %5 = arith.ori %3, %4 : i1 loc(#loc6) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %11 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c65_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: "llvm.intrcall"(%12, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc6) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc6) +// CHECK-NEXT: } loc(#loc6) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %2, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %7 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c1_i256, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc6) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c29400335157912315244266070412362164103369332044010299463143527189509193072640_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) // CHECK-NEXT: return %1 : i256 loc(#loc7) // CHECK-NEXT: } loc(#loc5) // CHECK-NEXT: func.func @name_interface_42() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: %c33018837946578446351252663693883661223784019064811567089376576689756478373888_i256 = arith.constant 33018837946578446351252663693883661223784019064811567089376576689756478373888 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c1_i256 = arith.constant 1 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %0 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) // CHECK-NEXT: %1 = llvm.load %0 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc9) // CHECK-NEXT: %2 = arith.addi %1, %c64_i256 : i256 loc(#loc9) -// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: llvm.store %2, %3 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %4 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: llvm.store %c1_i256, %4 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %5 = arith.addi %1, %c32_i256 : i256 loc(#loc9) -// CHECK-NEXT: %6 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: llvm.store %c33018837946578446351252663693883661223784019064811567089376576689756478373888_i256, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %3 = arith.cmpi ugt, %2, %c18446744073709551615_i256 : i256 loc(#loc9) +// CHECK-NEXT: %4 = arith.cmpi ult, %2, %1 : i256 loc(#loc9) +// CHECK-NEXT: %5 = arith.ori %3, %4 : i1 loc(#loc9) +// CHECK-NEXT: scf.if %5 { +// CHECK-NEXT: %10 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %10 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %11 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c65_i256, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %12 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: "llvm.intrcall"(%12, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc9) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc9) +// CHECK-NEXT: } loc(#loc9) +// CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %2, %6 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %7 = llvm.inttoptr %1 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c1_i256, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %8 = arith.addi %1, %c32_i256 : i256 loc(#loc9) +// CHECK-NEXT: %9 = llvm.inttoptr %8 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c33018837946578446351252663693883661223784019064811567089376576689756478373888_i256, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) // CHECK-NEXT: return %1 : i256 loc(#loc10) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: func.func @C_9() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { @@ -137,8 +212,8 @@ function name_interface() pure returns (string memory) { // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: #loc = loc(unknown) // CHECK-NEXT: #loc1 = loc({{.*}}:10:0) -// CHECK-NEXT: #loc2 = loc({{.*}}:12:0) -// CHECK-NEXT: #loc3 = loc({{.*}}:13:9) +// CHECK-NEXT: #loc2 = loc({{.*}}:13:9) +// CHECK-NEXT: #loc3 = loc({{.*}}:12:0) // CHECK-NEXT: #loc4 = loc({{.*}}:13:2) // CHECK-NEXT: #loc5 = loc({{.*}}:16:0) // CHECK-NEXT: #loc6 = loc({{.*}}:17:9) diff --git a/test/lit/mlirCodegen/EVM/type-object-code.sol b/test/lit/mlirCodegen/EVM/type-object-code.sol index 00582db1f..e985aca2e 100644 --- a/test/lit/mlirCodegen/EVM/type-object-code.sol +++ b/test/lit/mlirCodegen/EVM/type-object-code.sol @@ -22,10 +22,14 @@ function runtime_code_length() returns (uint256) { // NOTE: Assertions have been autogenerated by test/updFileCheckTest.py // CHECK: #Osaka = #sol // CHECK-NEXT: module @A_5 attributes {llvm.data_layout = "E-p:256:256-i256:256:256-S256-a:256:256", llvm.target_triple = "evm-unknown-unknown", sol.evm_version = #Osaka} { -// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { -// CHECK-NEXT: llvm.unreachable loc(#loc1) -// CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @__entry() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) +// CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) +// CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) // CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) // CHECK-NEXT: %c128_i256 = arith.constant 128 : i256 loc(#loc1) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) @@ -34,8 +38,8 @@ function runtime_code_length() returns (uint256) { // CHECK-NEXT: %1 = "llvm.intrcall"() <{id = 4040 : i32, name = "evm.callvalue"}> : () -> i256 loc(#loc1) // CHECK-NEXT: %2 = arith.cmpi ne, %1, %c0_i256 : i256 loc(#loc1) // CHECK-NEXT: scf.if %2 { -// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%19, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%24, %c0_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: } loc(#loc1) // CHECK-NEXT: %3 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5"], name = "evm.datasize"}> : () -> i256 loc(#loc1) @@ -43,49 +47,93 @@ function runtime_code_length() returns (uint256) { // CHECK-NEXT: %5 = arith.subi %4, %3 : i256 loc(#loc1) // CHECK-NEXT: %6 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) // CHECK-NEXT: %7 = llvm.load %6 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %8 = arith.addi %7, %5 : i256 loc(#loc1) -// CHECK-NEXT: %9 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: llvm.store %8, %9 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %10 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %11 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%10, %11, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %8 = arith.addi %5, %c31_i256 : i256 loc(#loc1) +// CHECK-NEXT: %9 = arith.andi %8, %c-32_i256 : i256 loc(#loc1) +// CHECK-NEXT: %10 = arith.addi %7, %9 : i256 loc(#loc1) +// CHECK-NEXT: %11 = arith.cmpi ugt, %10, %c18446744073709551615_i256 : i256 loc(#loc1) +// CHECK-NEXT: %12 = arith.cmpi ult, %10, %7 : i256 loc(#loc1) +// CHECK-NEXT: %13 = arith.ori %11, %12 : i1 loc(#loc1) +// CHECK-NEXT: scf.if %13 { +// CHECK-NEXT: %24 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %24 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %25 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %c65_i256, %25 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %26 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%26, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc1) +// CHECK-NEXT: } loc(#loc1) +// CHECK-NEXT: %14 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: llvm.store %10, %14 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %15 = llvm.inttoptr %7 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %16 = llvm.inttoptr %3 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %5) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) // CHECK-NEXT: call @A_5() : () -> () loc(#loc1) -// CHECK-NEXT: %12 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %13 = llvm.load %12 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) -// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %15 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) -// CHECK-NEXT: %16 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: %17 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc1) -// CHECK-NEXT: "llvm.intr.memcpy"(%16, %17, %15) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) -// CHECK-NEXT: %18 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc1) -// CHECK-NEXT: "llvm.intrcall"(%18, %15) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) +// CHECK-NEXT: %17 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc1) +// CHECK-NEXT: %19 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %20 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc1) +// CHECK-NEXT: %21 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: %22 = llvm.inttoptr %19 : i256 to !llvm.ptr<4> loc(#loc1) +// CHECK-NEXT: "llvm.intr.memcpy"(%21, %22, %20) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc1) +// CHECK-NEXT: %23 = llvm.inttoptr %18 : i256 to !llvm.ptr<1> loc(#loc1) +// CHECK-NEXT: "llvm.intrcall"(%23, %20) <{id = 4078 : i32, name = "evm.return"}> : (!llvm.ptr<1>, i256) -> () loc(#loc1) // CHECK-NEXT: call @".unreachable"() : () -> () loc(#loc1) // CHECK-NEXT: llvm.unreachable loc(#loc1) // CHECK-NEXT: } loc(#loc) +// CHECK-NEXT: func.func @".unreachable"() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: llvm.unreachable loc(#loc2) +// CHECK-NEXT: } loc(#loc) // CHECK-NEXT: func.func @creation_code_16() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) // CHECK-NEXT: %c31_i256 = arith.constant 31 : i256 loc(#loc) -// CHECK-NEXT: %0 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5"], name = "evm.datasize"}> : () -> i256 loc(#loc3) -// CHECK-NEXT: %1 = arith.addi %0, %c31_i256 : i256 loc(#loc3) -// CHECK-NEXT: %2 = arith.andi %1, %c-32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %3 = arith.addi %2, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc3) -// CHECK-NEXT: %6 = arith.addi %5, %3 : i256 loc(#loc3) -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %8 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: llvm.store %0, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %9 = arith.addi %5, %c32_i256 : i256 loc(#loc3) -// CHECK-NEXT: %10 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5"], name = "evm.dataoffset"}> : () -> i256 loc(#loc3) -// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc3) -// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<4> loc(#loc3) -// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc3) -// CHECK-NEXT: return %5 : i256 loc(#loc4) -// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %0 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5"], name = "evm.datasize"}> : () -> i256 loc(#loc2) +// CHECK-NEXT: %1 = arith.addi %0, %c31_i256 : i256 loc(#loc2) +// CHECK-NEXT: %2 = arith.andi %1, %c-32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc2) +// CHECK-NEXT: %5 = arith.addi %2, %c63_i256 : i256 loc(#loc2) +// CHECK-NEXT: %6 = arith.andi %5, %c-32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %7 = arith.addi %4, %6 : i256 loc(#loc2) +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 loc(#loc2) +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %4 : i256 loc(#loc2) +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 loc(#loc2) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc2) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc2) +// CHECK-NEXT: } loc(#loc2) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: llvm.store %0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %13 = arith.addi %4, %c32_i256 : i256 loc(#loc2) +// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5"], name = "evm.dataoffset"}> : () -> i256 loc(#loc2) +// CHECK-NEXT: %15 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc2) +// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc2) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc2) +// CHECK-NEXT: return %4 : i256 loc(#loc4) +// CHECK-NEXT: } loc(#loc3) // CHECK-NEXT: func.func @creation_code_length_28() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) @@ -93,24 +141,44 @@ function runtime_code_length() returns (uint256) { // CHECK-NEXT: %0 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5"], name = "evm.datasize"}> : () -> i256 loc(#loc6) // CHECK-NEXT: %1 = arith.addi %0, %c31_i256 : i256 loc(#loc6) // CHECK-NEXT: %2 = arith.andi %1, %c-32_i256 : i256 loc(#loc6) -// CHECK-NEXT: %3 = arith.addi %2, %c32_i256 : i256 loc(#loc6) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc6) -// CHECK-NEXT: %6 = arith.addi %5, %3 : i256 loc(#loc6) -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %8 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: llvm.store %0, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %9 = arith.addi %5, %c32_i256 : i256 loc(#loc6) -// CHECK-NEXT: %10 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5"], name = "evm.dataoffset"}> : () -> i256 loc(#loc6) -// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<4> loc(#loc6) -// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc6) -// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc6) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc6) -// CHECK-NEXT: return %14 : i256 loc(#loc7) +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc6) +// CHECK-NEXT: %5 = arith.addi %2, %c63_i256 : i256 loc(#loc6) +// CHECK-NEXT: %6 = arith.andi %5, %c-32_i256 : i256 loc(#loc6) +// CHECK-NEXT: %7 = arith.addi %4, %6 : i256 loc(#loc6) +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 loc(#loc6) +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %4 : i256 loc(#loc6) +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 loc(#loc6) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc6) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc6) +// CHECK-NEXT: } loc(#loc6) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: llvm.store %0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %13 = arith.addi %4, %c32_i256 : i256 loc(#loc6) +// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5"], name = "evm.dataoffset"}> : () -> i256 loc(#loc6) +// CHECK-NEXT: %15 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc6) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc6) +// CHECK-NEXT: %17 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc6) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc6) +// CHECK-NEXT: return %18 : i256 loc(#loc7) // CHECK-NEXT: } loc(#loc5) // CHECK-NEXT: func.func @runtime_code_39() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) @@ -118,22 +186,42 @@ function runtime_code_length() returns (uint256) { // CHECK-NEXT: %0 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc9) // CHECK-NEXT: %1 = arith.addi %0, %c31_i256 : i256 loc(#loc9) // CHECK-NEXT: %2 = arith.andi %1, %c-32_i256 : i256 loc(#loc9) -// CHECK-NEXT: %3 = arith.addi %2, %c32_i256 : i256 loc(#loc9) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc9) -// CHECK-NEXT: %6 = arith.addi %5, %3 : i256 loc(#loc9) -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %8 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: llvm.store %0, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %9 = arith.addi %5, %c32_i256 : i256 loc(#loc9) -// CHECK-NEXT: %10 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc9) -// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc9) -// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<4> loc(#loc9) -// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc9) -// CHECK-NEXT: return %5 : i256 loc(#loc10) +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc9) +// CHECK-NEXT: %5 = arith.addi %2, %c63_i256 : i256 loc(#loc9) +// CHECK-NEXT: %6 = arith.andi %5, %c-32_i256 : i256 loc(#loc9) +// CHECK-NEXT: %7 = arith.addi %4, %6 : i256 loc(#loc9) +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 loc(#loc9) +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %4 : i256 loc(#loc9) +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 loc(#loc9) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %17 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %17 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %18 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %c65_i256, %18 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: "llvm.intrcall"(%19, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc9) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc9) +// CHECK-NEXT: } loc(#loc9) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: llvm.store %0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %13 = arith.addi %4, %c32_i256 : i256 loc(#loc9) +// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc9) +// CHECK-NEXT: %15 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc9) +// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc9) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc9) +// CHECK-NEXT: return %4 : i256 loc(#loc10) // CHECK-NEXT: } loc(#loc8) // CHECK-NEXT: func.func @runtime_code_length_51() -> i256 attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { +// CHECK-NEXT: %c63_i256 = arith.constant 63 : i256 loc(#loc) +// CHECK-NEXT: %c36_i256 = arith.constant 36 : i256 loc(#loc) +// CHECK-NEXT: %c65_i256 = arith.constant 65 : i256 loc(#loc) +// CHECK-NEXT: %c4_i256 = arith.constant 4 : i256 loc(#loc) +// CHECK-NEXT: %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256 = arith.constant 35408467139433450592217433187231851964531694900788300625387963629091585785856 : i256 loc(#loc) +// CHECK-NEXT: %c0_i256 = arith.constant 0 : i256 loc(#loc) +// CHECK-NEXT: %c18446744073709551615_i256 = arith.constant 18446744073709551615 : i256 loc(#loc) // CHECK-NEXT: %c64_i256 = arith.constant 64 : i256 loc(#loc) // CHECK-NEXT: %c32_i256 = arith.constant 32 : i256 loc(#loc) // CHECK-NEXT: %c-32_i256 = arith.constant -32 : i256 loc(#loc) @@ -141,22 +229,35 @@ function runtime_code_length() returns (uint256) { // CHECK-NEXT: %0 = "llvm.intrcall"() <{id = 4047 : i32, metadata = ["A_5_deployed"], name = "evm.datasize"}> : () -> i256 loc(#loc12) // CHECK-NEXT: %1 = arith.addi %0, %c31_i256 : i256 loc(#loc12) // CHECK-NEXT: %2 = arith.andi %1, %c-32_i256 : i256 loc(#loc12) -// CHECK-NEXT: %3 = arith.addi %2, %c32_i256 : i256 loc(#loc12) -// CHECK-NEXT: %4 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) -// CHECK-NEXT: %5 = llvm.load %4 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc12) -// CHECK-NEXT: %6 = arith.addi %5, %3 : i256 loc(#loc12) -// CHECK-NEXT: %7 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) -// CHECK-NEXT: llvm.store %6, %7 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) -// CHECK-NEXT: %8 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc12) -// CHECK-NEXT: llvm.store %0, %8 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) -// CHECK-NEXT: %9 = arith.addi %5, %c32_i256 : i256 loc(#loc12) -// CHECK-NEXT: %10 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc12) -// CHECK-NEXT: %11 = llvm.inttoptr %9 : i256 to !llvm.ptr<1> loc(#loc12) -// CHECK-NEXT: %12 = llvm.inttoptr %10 : i256 to !llvm.ptr<4> loc(#loc12) -// CHECK-NEXT: "llvm.intr.memcpy"(%11, %12, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc12) -// CHECK-NEXT: %13 = llvm.inttoptr %5 : i256 to !llvm.ptr<1> loc(#loc12) -// CHECK-NEXT: %14 = llvm.load %13 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc12) -// CHECK-NEXT: return %14 : i256 loc(#loc13) +// CHECK-NEXT: %3 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %4 = llvm.load %3 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc12) +// CHECK-NEXT: %5 = arith.addi %2, %c63_i256 : i256 loc(#loc12) +// CHECK-NEXT: %6 = arith.andi %5, %c-32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %7 = arith.addi %4, %6 : i256 loc(#loc12) +// CHECK-NEXT: %8 = arith.cmpi ugt, %7, %c18446744073709551615_i256 : i256 loc(#loc12) +// CHECK-NEXT: %9 = arith.cmpi ult, %7, %4 : i256 loc(#loc12) +// CHECK-NEXT: %10 = arith.ori %8, %9 : i1 loc(#loc12) +// CHECK-NEXT: scf.if %10 { +// CHECK-NEXT: %19 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c35408467139433450592217433187231851964531694900788300625387963629091585785856_i256, %19 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %20 = llvm.inttoptr %c4_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %c65_i256, %20 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %21 = llvm.inttoptr %c0_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: "llvm.intrcall"(%21, %c36_i256) <{id = 4080 : i32, name = "evm.revert"}> : (!llvm.ptr<1>, i256) -> () loc(#loc12) +// CHECK-NEXT: func.call @".unreachable"() : () -> () loc(#loc12) +// CHECK-NEXT: } loc(#loc12) +// CHECK-NEXT: %11 = llvm.inttoptr %c64_i256 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %7, %11 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %12 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: llvm.store %0, %12 {alignment = 1 : i64} : i256, !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %13 = arith.addi %4, %c32_i256 : i256 loc(#loc12) +// CHECK-NEXT: %14 = "llvm.intrcall"() <{id = 4046 : i32, metadata = ["A_5_deployed"], name = "evm.dataoffset"}> : () -> i256 loc(#loc12) +// CHECK-NEXT: %15 = llvm.inttoptr %13 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %16 = llvm.inttoptr %14 : i256 to !llvm.ptr<4> loc(#loc12) +// CHECK-NEXT: "llvm.intr.memcpy"(%15, %16, %0) <{isVolatile = false}> : (!llvm.ptr<1>, !llvm.ptr<4>, i256) -> () loc(#loc12) +// CHECK-NEXT: %17 = llvm.inttoptr %4 : i256 to !llvm.ptr<1> loc(#loc12) +// CHECK-NEXT: %18 = llvm.load %17 {alignment = 1 : i64} : !llvm.ptr<1> -> i256 loc(#loc12) +// CHECK-NEXT: return %18 : i256 loc(#loc13) // CHECK-NEXT: } loc(#loc11) // CHECK-NEXT: func.func @A_5() attributes {llvm.linkage = #llvm.linkage, passthrough = ["nofree", "null_pointer_is_valid"]} { // CHECK-NEXT: return loc(#loc1) @@ -213,8 +314,8 @@ function runtime_code_length() returns (uint256) { // CHECK-NEXT: } loc(#loc) // CHECK-NEXT: #loc = loc(unknown) // CHECK-NEXT: #loc1 = loc({{.*}}:2:0) -// CHECK-NEXT: #loc2 = loc({{.*}}:6:0) -// CHECK-NEXT: #loc3 = loc({{.*}}:7:9) +// CHECK-NEXT: #loc2 = loc({{.*}}:7:9) +// CHECK-NEXT: #loc3 = loc({{.*}}:6:0) // CHECK-NEXT: #loc4 = loc({{.*}}:7:2) // CHECK-NEXT: #loc5 = loc({{.*}}:10:0) // CHECK-NEXT: #loc6 = loc({{.*}}:11:9)