forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-19 19:30:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

core/vm: splice make* factory closures into the generated switch

Browse source
This commit is contained in:
jonny rhea 2026-06-19 08:39:13 -05:00
parent ccbc468d4c
commit 840ae6006a
2 changed files with 274 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

115
core/vm/gen/main.go
View file

@ -115,6 +115,10 @@ type generator struct {
buf *bytes.Buffer buf *bytes.Buffer
} }
// p is the sole writer of the generated file. Every line of output is appended
// to g.buf through it. The splice helpers (inlineBody, inlineFactoryBody) only
// build text, which their callers then hand to p.
//
// p formats and appends generated Go, like fmt.Fprintf. A template can start on // p formats and appends generated Go, like fmt.Fprintf. A template can start on
// the line after p( and be indented to match its structure. p drops the leading // the line after p( and be indented to match its structure. p drops the leading
// newline and the indent before the closing backtick, and gofmt tidies the rest. // newline and the indent before the closing backtick, and gofmt tidies the rest.
@ -153,26 +157,84 @@ func parseHandlers(vmDir string) (*token.FileSet, map[string]*ast.FuncDecl) {
var returnRe = regexp.MustCompile(`^(\s*)return\s+([^,]+),\s*(.+)$`) var returnRe = regexp.MustCompile(`^(\s*)return\s+([^,]+),\s*(.+)$`)
// inlineBody returns the source of handler's body, rewritten so it can be // inlineBody returns a named handler's body, rewritten so it can be spliced
// spliced into the dispatch loop: the `*pc` dereference becomes the loop's `pc` // into the dispatch loop (see rewriteSplicedBody). The caller emits it with p.
// local, and each `return r0, r1` becomes loop control flow. Success
// (r1 == nil) advances pc and continues, an error sets err and breaks.
func (g *generator) inlineBody(handler string) string { func (g *generator) inlineBody(handler string) string {
fn := g.handlers[handler] fn := g.handlers[handler]
if fn == nil { if fn == nil {
fatalf("no handler %q to inline", handler) fatalf("no handler %q to inline", handler)
} }
return g.rewriteSplicedBody(g.renderAst(fn.Body.List))
}
// inlineFactoryBody splices the body of the executionFunc closure that a make*
// factory returns, substituting the factory's parameters with the per-opcode
// constants in args (positional, matching the factory signature). This lets
// closure-built handlers (makePush, makeDup) be derived from their single
// definition rather than restated in the generator. The caller emits the
// result with p.
func (g *generator) inlineFactoryBody(factory string, args ...int) string {
fn := g.handlers[factory]
if fn == nil {
fatalf("no factory %q to inline", factory)
}
lit := factoryClosure(factory, fn)
src := g.renderAst(lit.Body.List)
var names []string
for _, f := range fn.Type.Params.List {
for _, nm := range f.Names {
names = append(names, nm.Name)
}
}
if len(names) != len(args) {
fatalf("factory %q takes %d params, got %d args", factory, len(names), len(args))
}
for i, nm := range names {
src = regexp.MustCompile(`\b`+nm+`\b`).ReplaceAllString(src, fmt.Sprint(args[i]))
}
return g.rewriteSplicedBody(src)
}
// factoryClosure returns the executionFunc literal that a make* factory's body
// is a single `return func(...) {...}` of.
func factoryClosure(name string, fn *ast.FuncDecl) *ast.FuncLit {
if len(fn.Body.List) != 1 {
fatalf("factory %q body is not a single return", name)
}
ret, ok := fn.Body.List[0].(*ast.ReturnStmt)
if !ok || len(ret.Results) != 1 {
fatalf("factory %q does not return a single value", name)
}
lit, ok := ret.Results[0].(*ast.FuncLit)
if !ok {
fatalf("factory %q does not return a func literal", name)
}
return lit
}
// renderAst converts AST statements back to formatted Go source text, the
// inverse of parsing. It uses the generator's fileset and emits nothing itself
// (the caller passes the result to p).
func (g *generator) renderAst(stmts []ast.Stmt) string {
var raw bytes.Buffer var raw bytes.Buffer
cfg := printer.Config{Mode: printer.UseSpaces | printer.TabIndent, Tabwidth: 8} cfg := printer.Config{Mode: printer.UseSpaces | printer.TabIndent, Tabwidth: 8}
for _, stmt := range fn.Body.List { for _, stmt := range stmts {
if err := cfg.Fprint(&raw, g.fset, stmt); err != nil { if err := cfg.Fprint(&raw, g.fset, stmt); err != nil {
fatalf("print %s body: %v", handler, err) fatalf("print stmt: %v", err)
} }
raw.WriteByte('\n') raw.WriteByte('\n')
} }
src := strings.ReplaceAll(raw.String(), "*pc", "pc") return raw.String()
}
var out strings.Builder // rewriteSplicedBody rewrites a printed handler body so it runs inside the
// dispatch loop: the `*pc` dereference becomes the loop's `pc` local, and each
// `return r0, r1` becomes loop control flow. Success (r1 == nil) advances pc
// and continues, an error sets err and breaks. Stack helpers are then expanded.
func (g *generator) rewriteSplicedBody(src string) string {
src = strings.ReplaceAll(src, "*pc", "pc")
var out bytes.Buffer
for _, line := range strings.Split(src, "\n") { for _, line := range strings.Split(src, "\n") {
if m := returnRe.FindStringSubmatch(line); m != nil { if m := returnRe.FindStringSubmatch(line); m != nil {
indent, r0, r1 := m[1], strings.TrimSpace(m[2]), strings.TrimSpace(m[3]) indent, r0, r1 := m[1], strings.TrimSpace(m[2]), strings.TrimSpace(m[3])
@ -214,6 +276,7 @@ var (
pop2Re = regexp.MustCompile(`(?m)^(\s*)(\w+), (\w+) := scope\.Stack\.pop2\(\)$`) pop2Re = regexp.MustCompile(`(?m)^(\s*)(\w+), (\w+) := scope\.Stack\.pop2\(\)$`)
getAssignRe = regexp.MustCompile(`(?m)^(\s*)(\w+) := scope\.Stack\.get\(\)$`) getAssignRe = regexp.MustCompile(`(?m)^(\s*)(\w+) := scope\.Stack\.get\(\)$`)
getCallRe = regexp.MustCompile(`(?m)^(\s*)scope\.Stack\.get\(\)\.(\w+)\((.*)\)$`) getCallRe = regexp.MustCompile(`(?m)^(\s*)scope\.Stack\.get\(\)\.(\w+)\((.*)\)$`)
dupRe = regexp.MustCompile(`(?m)^(\s*)scope\.Stack\.dup\((\d+)\)$`)
varBlockRe = regexp.MustCompile(`(?ms)^(\s*)var \(\n(.*?)\n\s*\)$`) varBlockRe = regexp.MustCompile(`(?ms)^(\s*)var \(\n(.*?)\n\s*\)$`)
varMemberRe = regexp.MustCompile(`(?m)^\s*([\w, ]+?)\s*= (.*)$`) varMemberRe = regexp.MustCompile(`(?m)^\s*([\w, ]+?)\s*= (.*)$`)
) )
@ -239,6 +302,8 @@ func expandStackHelpers(src string) string {
"${1}$2 := &stack.inner.data[stack.inner.top]\n${1}stack.inner.top++\n${1}stack.size++") "${1}$2 := &stack.inner.data[stack.inner.top]\n${1}stack.inner.top++\n${1}stack.size++")
src = getCallRe.ReplaceAllString(src, src = getCallRe.ReplaceAllString(src,
"${1}stack.inner.data[stack.inner.top].$2($3)\n${1}stack.inner.top++\n${1}stack.size++") "${1}stack.inner.data[stack.inner.top].$2($3)\n${1}stack.inner.top++\n${1}stack.size++")
src = dupRe.ReplaceAllString(src,
"${1}stack.inner.data[stack.bottom+stack.size] = stack.inner.data[stack.bottom+stack.size-$2]\n${1}stack.size++\n${1}stack.inner.top++")
return src return src
} }
@ -363,16 +428,11 @@ func (g *generator) emitWork(code byte) {
} }
switch { switch {
case code >= 0x62 && code <= 0x7f: // PUSH3-PUSH32: inline makePush(n,n) case code >= 0x62 && code <= 0x7f: // PUSH3-PUSH32: splice makePush(n, n)
g.emitPushFixed(int(code) - 0x5f) n := int(code) - 0x5f
case code >= 0x80 && code <= 0x8f: // DUP1-DUP16: the dup body, emitted raw g.p("%s", g.inlineFactoryBody("makePush", n, n))
g.p(` case code >= 0x80 && code <= 0x8f: // DUP1-DUP16: splice makeDup(n)
stack.inner.data[stack.bottom+stack.size] = stack.inner.data[stack.bottom+stack.size-%d] g.p("%s", g.inlineFactoryBody("makeDup", int(code)-0x7f))
stack.size++
stack.inner.top++
pc++
continue mainLoop
`, int(code)-0x7f)
case code >= 0x90 && code <= 0x9f: // SWAP1-SWAP16: the swap body, emitted raw case code >= 0x90 && code <= 0x9f: // SWAP1-SWAP16: the swap body, emitted raw
n := int(code) - 0x8f n := int(code) - 0x8f
g.p(` g.p(`
@ -385,25 +445,6 @@ func (g *generator) emitWork(code byte) {
} }
} }
// emitPushFixed inlines makePush(n, n) for PUSH<n> (n = 3..32).
func (g *generator) emitPushFixed(n int) {
g.p(`
codeLen := len(scope.Contract.Code)
start := min(codeLen, int(pc+1))
end := min(codeLen, start+%d)
a := &stack.inner.data[stack.inner.top]
stack.inner.top++
stack.size++
a.SetBytes(scope.Contract.Code[start:end])
if missing := %d - (end - start); missing > 0 {
a.Lsh(a, uint(8*missing))
}
pc += %d
pc++
continue mainLoop
`, n, n, n)
}
func (g *generator) emitInlineCase(code byte) { func (g *generator) emitInlineCase(code byte) {
m := g.meta[code] m := g.meta[code]
g.p("case %s:\n", m.name) g.p("case %s:\n", m.name)

286
core/vm/interp_gen.go
View file

@ -827,9 +827,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+3) start = min(codeLen, int(pc+1))
end = min(codeLen, start+3)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -840,6 +842,7 @@ mainLoop:
pc += 3 pc += 3
pc++ pc++
continue mainLoop continue mainLoop
case PUSH4: case PUSH4:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -856,9 +859,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+4) start = min(codeLen, int(pc+1))
end = min(codeLen, start+4)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -869,6 +874,7 @@ mainLoop:
pc += 4 pc += 4
pc++ pc++
continue mainLoop continue mainLoop
case PUSH5: case PUSH5:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -885,9 +891,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+5) start = min(codeLen, int(pc+1))
end = min(codeLen, start+5)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -898,6 +906,7 @@ mainLoop:
pc += 5 pc += 5
pc++ pc++
continue mainLoop continue mainLoop
case PUSH6: case PUSH6:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -914,9 +923,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+6) start = min(codeLen, int(pc+1))
end = min(codeLen, start+6)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -927,6 +938,7 @@ mainLoop:
pc += 6 pc += 6
pc++ pc++
continue mainLoop continue mainLoop
case PUSH7: case PUSH7:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -943,9 +955,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+7) start = min(codeLen, int(pc+1))
end = min(codeLen, start+7)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -956,6 +970,7 @@ mainLoop:
pc += 7 pc += 7
pc++ pc++
continue mainLoop continue mainLoop
case PUSH8: case PUSH8:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -972,9 +987,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+8) start = min(codeLen, int(pc+1))
end = min(codeLen, start+8)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -985,6 +1002,7 @@ mainLoop:
pc += 8 pc += 8
pc++ pc++
continue mainLoop continue mainLoop
case PUSH9: case PUSH9:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1001,9 +1019,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+9) start = min(codeLen, int(pc+1))
end = min(codeLen, start+9)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1014,6 +1034,7 @@ mainLoop:
pc += 9 pc += 9
pc++ pc++
continue mainLoop continue mainLoop
case PUSH10: case PUSH10:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1030,9 +1051,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+10) start = min(codeLen, int(pc+1))
end = min(codeLen, start+10)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1043,6 +1066,7 @@ mainLoop:
pc += 10 pc += 10
pc++ pc++
continue mainLoop continue mainLoop
case PUSH11: case PUSH11:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1059,9 +1083,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+11) start = min(codeLen, int(pc+1))
end = min(codeLen, start+11)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1072,6 +1098,7 @@ mainLoop:
pc += 11 pc += 11
pc++ pc++
continue mainLoop continue mainLoop
case PUSH12: case PUSH12:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1088,9 +1115,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+12) start = min(codeLen, int(pc+1))
end = min(codeLen, start+12)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1101,6 +1130,7 @@ mainLoop:
pc += 12 pc += 12
pc++ pc++
continue mainLoop continue mainLoop
case PUSH13: case PUSH13:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1117,9 +1147,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+13) start = min(codeLen, int(pc+1))
end = min(codeLen, start+13)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1130,6 +1162,7 @@ mainLoop:
pc += 13 pc += 13
pc++ pc++
continue mainLoop continue mainLoop
case PUSH14: case PUSH14:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1146,9 +1179,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+14) start = min(codeLen, int(pc+1))
end = min(codeLen, start+14)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1159,6 +1194,7 @@ mainLoop:
pc += 14 pc += 14
pc++ pc++
continue mainLoop continue mainLoop
case PUSH15: case PUSH15:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1175,9 +1211,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+15) start = min(codeLen, int(pc+1))
end = min(codeLen, start+15)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1188,6 +1226,7 @@ mainLoop:
pc += 15 pc += 15
pc++ pc++
continue mainLoop continue mainLoop
case PUSH16: case PUSH16:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1204,9 +1243,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+16) start = min(codeLen, int(pc+1))
end = min(codeLen, start+16)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1217,6 +1258,7 @@ mainLoop:
pc += 16 pc += 16
pc++ pc++
continue mainLoop continue mainLoop
case PUSH17: case PUSH17:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1233,9 +1275,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+17) start = min(codeLen, int(pc+1))
end = min(codeLen, start+17)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1246,6 +1290,7 @@ mainLoop:
pc += 17 pc += 17
pc++ pc++
continue mainLoop continue mainLoop
case PUSH18: case PUSH18:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1262,9 +1307,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+18) start = min(codeLen, int(pc+1))
end = min(codeLen, start+18)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1275,6 +1322,7 @@ mainLoop:
pc += 18 pc += 18
pc++ pc++
continue mainLoop continue mainLoop
case PUSH19: case PUSH19:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1291,9 +1339,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+19) start = min(codeLen, int(pc+1))
end = min(codeLen, start+19)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1304,6 +1354,7 @@ mainLoop:
pc += 19 pc += 19
pc++ pc++
continue mainLoop continue mainLoop
case PUSH20: case PUSH20:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1320,9 +1371,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+20) start = min(codeLen, int(pc+1))
end = min(codeLen, start+20)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1333,6 +1386,7 @@ mainLoop:
pc += 20 pc += 20
pc++ pc++
continue mainLoop continue mainLoop
case PUSH21: case PUSH21:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1349,9 +1403,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+21) start = min(codeLen, int(pc+1))
end = min(codeLen, start+21)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1362,6 +1418,7 @@ mainLoop:
pc += 21 pc += 21
pc++ pc++
continue mainLoop continue mainLoop
case PUSH22: case PUSH22:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1378,9 +1435,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+22) start = min(codeLen, int(pc+1))
end = min(codeLen, start+22)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1391,6 +1450,7 @@ mainLoop:
pc += 22 pc += 22
pc++ pc++
continue mainLoop continue mainLoop
case PUSH23: case PUSH23:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1407,9 +1467,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+23) start = min(codeLen, int(pc+1))
end = min(codeLen, start+23)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1420,6 +1482,7 @@ mainLoop:
pc += 23 pc += 23
pc++ pc++
continue mainLoop continue mainLoop
case PUSH24: case PUSH24:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1436,9 +1499,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+24) start = min(codeLen, int(pc+1))
end = min(codeLen, start+24)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1449,6 +1514,7 @@ mainLoop:
pc += 24 pc += 24
pc++ pc++
continue mainLoop continue mainLoop
case PUSH25: case PUSH25:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1465,9 +1531,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+25) start = min(codeLen, int(pc+1))
end = min(codeLen, start+25)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1478,6 +1546,7 @@ mainLoop:
pc += 25 pc += 25
pc++ pc++
continue mainLoop continue mainLoop
case PUSH26: case PUSH26:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1494,9 +1563,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+26) start = min(codeLen, int(pc+1))
end = min(codeLen, start+26)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1507,6 +1578,7 @@ mainLoop:
pc += 26 pc += 26
pc++ pc++
continue mainLoop continue mainLoop
case PUSH27: case PUSH27:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1523,9 +1595,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+27) start = min(codeLen, int(pc+1))
end = min(codeLen, start+27)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1536,6 +1610,7 @@ mainLoop:
pc += 27 pc += 27
pc++ pc++
continue mainLoop continue mainLoop
case PUSH28: case PUSH28:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1552,9 +1627,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+28) start = min(codeLen, int(pc+1))
end = min(codeLen, start+28)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1565,6 +1642,7 @@ mainLoop:
pc += 28 pc += 28
pc++ pc++
continue mainLoop continue mainLoop
case PUSH29: case PUSH29:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1581,9 +1659,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+29) start = min(codeLen, int(pc+1))
end = min(codeLen, start+29)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1594,6 +1674,7 @@ mainLoop:
pc += 29 pc += 29
pc++ pc++
continue mainLoop continue mainLoop
case PUSH30: case PUSH30:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1610,9 +1691,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+30) start = min(codeLen, int(pc+1))
end = min(codeLen, start+30)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1623,6 +1706,7 @@ mainLoop:
pc += 30 pc += 30
pc++ pc++
continue mainLoop continue mainLoop
case PUSH31: case PUSH31:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1639,9 +1723,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+31) start = min(codeLen, int(pc+1))
end = min(codeLen, start+31)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1652,6 +1738,7 @@ mainLoop:
pc += 31 pc += 31
pc++ pc++
continue mainLoop continue mainLoop
case PUSH32: case PUSH32:
if sLen := stack.len(); sLen > 1023 { if sLen := stack.len(); sLen > 1023 {
return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023} return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@ -1668,9 +1755,11 @@ mainLoop:
pc++ pc++
continue mainLoop continue mainLoop
} }
codeLen := len(scope.Contract.Code) var (
start := min(codeLen, int(pc+1)) codeLen = len(scope.Contract.Code)
end := min(codeLen, start+32) start = min(codeLen, int(pc+1))
end = min(codeLen, start+32)
)
a := &stack.inner.data[stack.inner.top] a := &stack.inner.data[stack.inner.top]
stack.inner.top++ stack.inner.top++
stack.size++ stack.size++
@ -1681,6 +1770,7 @@ mainLoop:
pc += 32 pc += 32
pc++ pc++
continue mainLoop continue mainLoop
case DUP1: case DUP1:
if sLen := stack.len(); sLen < 1 { if sLen := stack.len(); sLen < 1 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 1} return nil, &ErrStackUnderflow{stackLen: sLen, required: 1}
@ -1696,6 +1786,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP2: case DUP2:
if sLen := stack.len(); sLen < 2 { if sLen := stack.len(); sLen < 2 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 2} return nil, &ErrStackUnderflow{stackLen: sLen, required: 2}
@ -1711,6 +1802,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP3: case DUP3:
if sLen := stack.len(); sLen < 3 { if sLen := stack.len(); sLen < 3 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 3} return nil, &ErrStackUnderflow{stackLen: sLen, required: 3}
@ -1726,6 +1818,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP4: case DUP4:
if sLen := stack.len(); sLen < 4 { if sLen := stack.len(); sLen < 4 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 4} return nil, &ErrStackUnderflow{stackLen: sLen, required: 4}
@ -1741,6 +1834,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP5: case DUP5:
if sLen := stack.len(); sLen < 5 { if sLen := stack.len(); sLen < 5 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 5} return nil, &ErrStackUnderflow{stackLen: sLen, required: 5}
@ -1756,6 +1850,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP6: case DUP6:
if sLen := stack.len(); sLen < 6 { if sLen := stack.len(); sLen < 6 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 6} return nil, &ErrStackUnderflow{stackLen: sLen, required: 6}
@ -1771,6 +1866,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP7: case DUP7:
if sLen := stack.len(); sLen < 7 { if sLen := stack.len(); sLen < 7 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 7} return nil, &ErrStackUnderflow{stackLen: sLen, required: 7}
@ -1786,6 +1882,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP8: case DUP8:
if sLen := stack.len(); sLen < 8 { if sLen := stack.len(); sLen < 8 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 8} return nil, &ErrStackUnderflow{stackLen: sLen, required: 8}
@ -1801,6 +1898,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP9: case DUP9:
if sLen := stack.len(); sLen < 9 { if sLen := stack.len(); sLen < 9 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 9} return nil, &ErrStackUnderflow{stackLen: sLen, required: 9}
@ -1816,6 +1914,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP10: case DUP10:
if sLen := stack.len(); sLen < 10 { if sLen := stack.len(); sLen < 10 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 10} return nil, &ErrStackUnderflow{stackLen: sLen, required: 10}
@ -1831,6 +1930,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP11: case DUP11:
if sLen := stack.len(); sLen < 11 { if sLen := stack.len(); sLen < 11 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 11} return nil, &ErrStackUnderflow{stackLen: sLen, required: 11}
@ -1846,6 +1946,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP12: case DUP12:
if sLen := stack.len(); sLen < 12 { if sLen := stack.len(); sLen < 12 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 12} return nil, &ErrStackUnderflow{stackLen: sLen, required: 12}
@ -1861,6 +1962,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP13: case DUP13:
if sLen := stack.len(); sLen < 13 { if sLen := stack.len(); sLen < 13 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 13} return nil, &ErrStackUnderflow{stackLen: sLen, required: 13}
@ -1876,6 +1978,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP14: case DUP14:
if sLen := stack.len(); sLen < 14 { if sLen := stack.len(); sLen < 14 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 14} return nil, &ErrStackUnderflow{stackLen: sLen, required: 14}
@ -1891,6 +1994,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP15: case DUP15:
if sLen := stack.len(); sLen < 15 { if sLen := stack.len(); sLen < 15 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 15} return nil, &ErrStackUnderflow{stackLen: sLen, required: 15}
@ -1906,6 +2010,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case DUP16: case DUP16:
if sLen := stack.len(); sLen < 16 { if sLen := stack.len(); sLen < 16 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 16} return nil, &ErrStackUnderflow{stackLen: sLen, required: 16}
@ -1921,6 +2026,7 @@ mainLoop:
stack.inner.top++ stack.inner.top++
pc++ pc++
continue mainLoop continue mainLoop
case SWAP1: case SWAP1:
if sLen := stack.len(); sLen < 2 { if sLen := stack.len(); sLen < 2 {
return nil, &ErrStackUnderflow{stackLen: sLen, required: 2} return nil, &ErrStackUnderflow{stackLen: sLen, required: 2}