github.com/FusionFoundation/efsn/v4@v4.2.0/core/vm/memory.go (about) 1 // Copyright 2015 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package vm 18 19 import ( 20 "fmt" 21 "github.com/holiman/uint256" 22 ) 23 24 // Memory implements a simple memory model for the ethereum virtual machine. 25 type Memory struct { 26 store []byte 27 lastGasCost uint64 28 } 29 30 // NewMemory returns a new memory memory model. 31 func NewMemory() *Memory { 32 return &Memory{} 33 } 34 35 // Set sets offset + size to value 36 func (m *Memory) Set(offset, size uint64, value []byte) { 37 // It's possible the offset is greater than 0 and size equals 0. This is because 38 // the calcMemSize (common.go) could potentially return 0 when size is zero (NO-OP) 39 if size > 0 { 40 // length of store may never be less than offset + size. 41 // The store should be resized PRIOR to setting the memory 42 if offset+size > uint64(len(m.store)) { 43 panic("invalid memory: store empty") 44 } 45 copy(m.store[offset:offset+size], value) 46 } 47 } 48 49 // Set32 sets the 32 bytes starting at offset to the value of val, left-padded with zeroes to 50 // 32 bytes. 51 func (m *Memory) Set32(offset uint64, val *uint256.Int) { 52 // length of store may never be less than offset + size. 53 // The store should be resized PRIOR to setting the memory 54 if offset+32 > uint64(len(m.store)) { 55 panic("invalid memory: store empty") 56 } 57 // Zero the memory area 58 copy(m.store[offset:offset+32], []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}) 59 // Fill in relevant bits 60 val.WriteToSlice(m.store[offset:]) 61 } 62 63 // Resize resizes the memory to size 64 func (m *Memory) Resize(size uint64) { 65 if uint64(m.Len()) < size { 66 m.store = append(m.store, make([]byte, size-uint64(m.Len()))...) 67 } 68 } 69 70 // Get returns offset + size as a new slice 71 func (m *Memory) GetCopy(offset, size int64) (cpy []byte) { 72 if size == 0 { 73 return nil 74 } 75 76 if len(m.store) > int(offset) { 77 cpy = make([]byte, size) 78 copy(cpy, m.store[offset:offset+size]) 79 80 return 81 } 82 83 return 84 } 85 86 // GetPtr returns the offset + size 87 func (m *Memory) GetPtr(offset, size int64) []byte { 88 if size == 0 { 89 return nil 90 } 91 92 if len(m.store) > int(offset) { 93 return m.store[offset : offset+size] 94 } 95 96 return nil 97 } 98 99 // Len returns the length of the backing slice 100 func (m *Memory) Len() int { 101 return len(m.store) 102 } 103 104 // Data returns the backing slice 105 func (m *Memory) Data() []byte { 106 return m.store 107 } 108 109 // Print dumps the content of the memory. 110 func (m *Memory) Print() { 111 fmt.Printf("### mem %d bytes ###\n", len(m.store)) 112 if len(m.store) > 0 { 113 addr := 0 114 for i := 0; i+32 <= len(m.store); i += 32 { 115 fmt.Printf("%03d: % x\n", addr, m.store[i:i+32]) 116 addr++ 117 } 118 } else { 119 fmt.Println("-- empty --") 120 } 121 fmt.Println("####################") 122 }