Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Bitwise shifting instructions in EVM #215

Merged
merged 12 commits into from
Sep 22, 2017
+94 −0
Merged

Bitwise shifting instructions in EVM #215

Changes from 1 commit
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
4bab879
Draft of bitwise shifting opcodes
axic Feb 13, 2017
a63aef3
Remove ROR/ROL
axic Apr 23, 2017
0b34616
Add link to client support (cpp-ethereum)
axic Apr 23, 2017
7bc4477
Swap shift operands (value is the top item)
axic Apr 23, 2017
27847a8
Rename to EIP145
axic Apr 23, 2017
d4f5382
Clarify shift amount (arg2)
axic Apr 23, 2017
e5ca919
Use floor and not udiv/sdiv
axic Jul 3, 2017
4218665
Explain sign of arg1/arg2
axic Jul 3, 2017
0b08d11
Add comparison with current opcodes
axic Jul 31, 2017
9464fa7
Clarify text (user -> use)
axic Sep 22, 2017
d01c9af
Swapp operand order for bitwise shifting
axic Sep 22, 2017
74d9a17
Clarify wording about arg1/arg2
axic Sep 22, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
38 changes: 19 additions & 19 deletions EIPS/eip-145.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,51 +27,51 @@ The following instructions are introduced:

### `0x1b`: `SHL` (shift left)

The `SHL` instruction (shift left) pops 2 values from the stack, `arg1` and `arg2`, and pushes on the stack the first popped value `arg1` shifted to the left by the number of bits in the second popped value `arg2`. The result is equal to
The `SHL` instruction (shift left) pops 2 values from the stack, `arg1` and `arg2`, and pushes on the stack the second popped value `arg2` shifted to the left by the number of bits in the first popped value `arg1`. The result is equal to
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I would skip "second popped" / "first popped". If the order is not clear, it should be clarified in the first part of the sentence.

How about

... pushes on the stack the result of the arg2 shifted to the left by the number of bits in arg1.

Copy link
Member Author

@axic axic Sep 22, 2017 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actually:

shifted to the left by arg1 number of bits

wouldn't be more readable?


```
(arg1 * 2^arg2) mod 2^256
(arg2 * 2^arg1) mod 2^256
```

Notes:
- The value (`arg1`) is interpreted as an unsigned number.
- The shift amount (`arg2`) is interpreted as an unsigned number.
- If the shift amount (`arg2`) is greater or equal 256 the result is 0.
- This is equivalent to `SWAP1 PUSH1 2 EXP MUL`.
- The value (`arg2`) is interpreted as an unsigned number.
- The shift amount (`arg1`) is interpreted as an unsigned number.
- If the shift amount (`arg1`) is greater or equal 256 the result is 0.
- This is equivalent to `PUSH1 2 EXP MUL`.

### `0x1c`: `SHR` (logical shift right)

The `SHR` instruction (logical shift right) pops 2 values from the stack, `arg1` and `arg2`, and pushes on the stack the first popped value `arg1` shifted to the right by the number of bits in the second popped value `arg2` with zero fill. The result is equal to
The `SHR` instruction (logical shift right) pops 2 values from the stack, `arg1` and `arg2`, and pushes on the stack the second popped value `arg2` shifted to the right by the number of bits in the first popped value `arg1` with zero fill. The result is equal to

```
floor(arg1 / 2^arg2)
floor(arg2 / 2^arg1)
```

Notes:
- The value (`arg1`) is interpreted as an unsigned number.
- The shift amount (`arg2`) is interpreted as an unsigned number.
- If the shift amount (`arg2`) is greater or equal 256 the result is 0.
- This is equivalent to `SWAP1 PUSH1 2 EXP DIV`.
- The value (`arg2`) is interpreted as an unsigned number.
- The shift amount (`arg1`) is interpreted as an unsigned number.
- If the shift amount (`arg1`) is greater or equal 256 the result is 0.
- This is equivalent to `PUSH1 2 EXP DIV`.

### `0x1d`: `SAR` (arithmetic shift right)

The `SAR` instruction (arithmetic shift right) pops 2 values from the stack, `arg1` and `arg2`, and pushes on the stack the first popped value `arg1` shifted to the right by the number of bits in the second popped value `arg2` with sign extension. The result is equal to
The `SAR` instruction (arithmetic shift right) pops 2 values from the stack, `arg1` and `arg2`, and pushes on the stack the second popped value `arg2` shifted to the right by the number of bits in the first popped value `arg1` with sign extension. The result is equal to

```
floor(arg1 / 2^arg2)
floor(arg2 / 2^arg1)
```

Notes:
- The value (`arg1`) is interpreted as a signed number.
- The shift amount (`arg2`) is interpreted as an unsigned number.
- If the shift amount (`arg2`) is greater or equal 256 the result is 0 if `arg1` is non-negative or -1 if `arg1` is negative.
- This is **not** equivalent to `SWAP1 PUSH1 2 EXP SDIV`, since it rounds differently. See `SDIV(-1, 2) == 0`, while `SAR(-1, 1) == -1`.
- The value (`arg2`) is interpreted as a signed number.
- The shift amount (`arg1`) is interpreted as an unsigned number.
- If the shift amount (`arg1`) is greater or equal 256 the result is 0 if `arg2` is non-negative or -1 if `arg2` is negative.
- This is **not** equivalent to `PUSH1 2 EXP SDIV`, since it rounds differently. See `SDIV(-1, 2) == 0`, while `SAR(-1, 1) == -1`.

The cost of the shift instructions is set at `verylow` tier (3 gas).

## Rationale

Instruction operands were chosen to match the other logical and arithmetic instructions.
Instruction operands were chosen to fit the more natural use case of shifting a value already on the stack. This means the operand order is swapped compared to most arithmetic insturctions.

## Backwards Compatibility

Expand Down