no-cc

core/opcodeCompiler/compiler/opcodeProcessor.go

@@ -3,8 +3,6 @@ package compiler
 import (
 	"errors"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/holiman/uint256"
 	"runtime"
 	"sync"
 )
@@ -20,8 +18,8 @@ var opcodeProcessor *OpcodeProcessor
 const taskChannelSize = 1024 * 1024
 
 type OpcodeProcessor struct {
-	enabled     bool
-	codeCache   *OpCodeCache
+	enabled bool
+	//codeCache   *OpCodeCache
 	taskChannel chan optimizeTask
 }
 
@@ -47,8 +45,8 @@ type optimizeTask struct {
 func GetOpcodeProcessorInstance() *OpcodeProcessor {
 	initOnce.Do(func() {
 		opcodeProcessor = &OpcodeProcessor{
-			enabled:     false,
-			codeCache:   nil,
+			enabled: false,
+			//codeCache:   nil,
 			taskChannel: make(chan optimizeTask, taskChannelSize),
 		}
 		// start task processors.
@@ -66,23 +64,25 @@ func (p *OpcodeProcessor) EnableOptimization() {
 		return
 	}
 	p.enabled = true
-	p.codeCache = getOpCodeCacheInstance()
+	//p.codeCache = getOpCodeCacheInstance()
 }
 
 func (p *OpcodeProcessor) DisableOptimization() {
 	p.enabled = false
 }
 
 // Producer functions
-func (p *OpcodeProcessor) LoadOptimizedCode(address common.Address, hash common.Hash) OptCode {
-	if !p.enabled {
+func (p *OpcodeProcessor) LoadOptimizedCode(address common.Address, hash common.Hash) []byte {
+	/*if !p.enabled {
 		return nil
 	}
-	/* Try load from cache */
+	// Try load from cache
 	codeCache := p.codeCache
 	processedCode := codeCache.GetCachedCode(address, hash)
 	return processedCode
 
+	*/
+	return nil
 }
 
 func (p *OpcodeProcessor) GenOrLoadOptimizedCode(address common.Address, code []byte, hash common.Hash) {
@@ -113,14 +113,18 @@ func (p *OpcodeProcessor) taskProcessor() {
 }
 
 func (p *OpcodeProcessor) handleOptimizationTask(task optimizeTask) {
-	switch task.taskType {
-	case generate:
-		p.TryGenerateOptimizedCode(task.addr, task.rawCode, task.codeHash)
-	case flush:
-		p.DeleteCodeCache(task.addr, task.codeHash)
-	}
+	/*
+		switch task.taskType {
+
+		case generate:
+			p.TryGenerateOptimizedCode(task.addr, task.rawCode, task.codeHash)
+		case flush:
+			p.DeleteCodeCache(task.addr, task.codeHash)
+		}
+	*/
 }
 
+/*
 // GenOrRewriteOptimizedCode generate the optimized code and refresh the codecache.
 func (p *OpcodeProcessor) GenOrRewriteOptimizedCode(address common.Address, code []byte, hash common.Hash) (OptCode, error) {
 	if !p.enabled {
@@ -143,7 +147,7 @@ func (p *OpcodeProcessor) TryGenerateOptimizedCode(address common.Address, code
 	if !p.enabled {
 		return nil, false, ErrOptiDisabled
 	}
-	/* Try load from cache */
+	// Try load from cache
 	codeCache := p.codeCache
 	processedCode := codeCache.GetCachedCode(address, hash)
 	hit := false
@@ -454,3 +458,4 @@ func calculateSkipSteps(code []byte, cur int) (skip bool, steps int) {
 	}
 	return skip, steps
 }
+*/

core/vm/instructions.go

@@ -18,7 +18,6 @@ package vm
 
 import (
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/opcodeCompiler/compiler"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
@@ -936,12 +935,9 @@ func opShlAndSub(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) (
 	y := scope.Contract.Code[*pc+2]
 	z := scope.Contract.Code[*pc+3]
 
-	result := compiler.GetOpcodeProcessorInstance().GetValFromShlAndSubMap(x, y, z)
-	if result != nil {
-		result = uint256.NewInt(uint64(y))
-		result.Lsh(result, uint(z))
-		result.Sub(result, uint256.NewInt(uint64(x)))
-	}
+	result := uint256.NewInt(uint64(y))
+	result.Lsh(result, uint(z))
+	result.Sub(result, uint256.NewInt(uint64(x)))
 
 	scope.Stack.push(result)
 	*pc += 7