roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

common/math, core/vm: Un-expose bigEndianByteAt, use correct terms for endianness

Browse Source
This commit is contained in:
Martin Holst Swende 2017-06-06 18:38:38 +02:00
parent 3285a0fda3
commit 1496b3aff6
3 changed files with 19 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
common/math/big.go
View File

@ -130,10 +130,10 @@ func PaddedBigBytes(bigint *big.Int, n int) []byte {
return ret return ret
} }
// LittleEndianByteAt returns the byte at position n, // bigEndianByteAt returns the byte at position n,
// if bigint is considered little-endian. // if bigint is considered big-endian.
// So n==0 gives the least significant byte // So n==0 returns the least significant byte
func LittleEndianByteAt(bigint *big.Int, n int) byte { func bigEndianByteAt(bigint *big.Int, n int) byte {
words := bigint.Bits() words := bigint.Bits()
// Check word-bucket the byte will reside in // Check word-bucket the byte will reside in
i := n / wordBytes i := n / wordBytes
@ -147,15 +147,15 @@ func LittleEndianByteAt(bigint *big.Int, n int) byte {
return byte(word >> shift) return byte(word >> shift)
} }
// BigEndian32ByteAt returns the byte at position n, // Byte returns the byte at position n,
// if bigint is considered big-endian. // if bigint is considered little-endian with the supplied padlength.
// So n==0 gives the most significant byte // n==0 returns the most significant byte
// WARNING: Only works for bigints in 32-byte range // bigint '5', padlength 32, n=31 => 5
func BigEndian32ByteAt(bigint *big.Int, n int) byte { func Byte(bigint *big.Int, padlength, n int) byte {
if n > 31 { if n >= padlength {
return byte(0) return byte(0)
} }
return LittleEndianByteAt(bigint, 31-n) return bigEndianByteAt(bigint, padlength-1-n)
} }
// ReadBits encodes the absolute value of bigint as big-endian bytes. Callers must ensure // ReadBits encodes the absolute value of bigint as big-endian bytes. Callers must ensure

11
common/math/big_test.go
View File

@ -157,13 +157,13 @@ func BenchmarkPaddedBigBytesSmallOnePadding(b *testing.B) {
func BenchmarkByteAtBrandNew(b *testing.B) { func BenchmarkByteAtBrandNew(b *testing.B) {
bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC") bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC")
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
BigEndian32ByteAt(bigint, 15) bigEndianByteAt(bigint, 15)
} }
} }
func BenchmarkByteAt(b *testing.B) { func BenchmarkByteAt(b *testing.B) {
bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC") bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC")
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
BigEndian32ByteAt(bigint, 15) bigEndianByteAt(bigint, 15)
} }
} }
func BenchmarkByteAtOld(b *testing.B) { func BenchmarkByteAtOld(b *testing.B) {
@ -225,7 +225,7 @@ func TestLittleEndianByteAt(t *testing.T) {
} }
for _, test := range tests { for _, test := range tests {
v := new(big.Int).SetBytes(common.Hex2Bytes(test.x)) v := new(big.Int).SetBytes(common.Hex2Bytes(test.x))
actual := LittleEndianByteAt(v, test.y) actual := bigEndianByteAt(v, test.y)
if actual != test.exp { if actual != test.exp {
t.Fatalf("Expected [%v] %v:th byte to be %v, was %v.", test.x, test.y, test.exp, actual) t.Fatalf("Expected [%v] %v:th byte to be %v, was %v.", test.x, test.y, test.exp, actual)
} }
@ -254,11 +254,12 @@ func TestBigEndianByteAt(t *testing.T) {
{"0000000000000000000000000000000000000000000000000000000000102030", 31, 0x30}, {"0000000000000000000000000000000000000000000000000000000000102030", 31, 0x30},
{"0000000000000000000000000000000000000000000000000000000000102030", 30, 0x20}, {"0000000000000000000000000000000000000000000000000000000000102030", 30, 0x20},
{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 32, 0x0}, {"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 32, 0x0},
{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 0xFFFFFFFF, 0x0}, {"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 31, 0xFF},
{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 0xFFFF, 0x0},
} }
for _, test := range tests { for _, test := range tests {
v := new(big.Int).SetBytes(common.Hex2Bytes(test.x)) v := new(big.Int).SetBytes(common.Hex2Bytes(test.x))
actual := BigEndian32ByteAt(v, test.y) actual := Byte(v, 32, test.y)
if actual != test.exp { if actual != test.exp {
t.Fatalf("Expected [%v] %v:th byte to be %v, was %v.", test.x, test.y, test.exp, actual) t.Fatalf("Expected [%v] %v:th byte to be %v, was %v.", test.x, test.y, test.exp, actual)
} }

4
core/vm/instructions.go
View File

@ -258,8 +258,8 @@ func opXor(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac
func opByte(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { func opByte(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
th, val := stack.pop(), stack.peek() th, val := stack.pop(), stack.peek()
if th.Cmp(common.Big32) < 0 { if th.Cmp(common.Big32) < 0 {
b := math.BigEndian32ByteAt(val, int(th.Int64())) b := math.Byte(val, 32, int(th.Int64()))
val.SetInt64(int64(b)) val.SetUint64(uint64(b))
} else { } else {
val.SetUint64(0) val.SetUint64(0)
} }