fix: handle undefined for unsupported opcode (#244)

Author: starwarfan

src/action/evm_bytecode_visitor.h

@@ -545,7 +545,9 @@ template <typename IRBuilder> class EVMByteCodeVisitor {
 
         case OP_SELFDESTRUCT: {
           Operand Beneficiary = pop();
+          handleEndBlock();
           Builder.handleSelfDestruct(Beneficiary);
+          InDeadCode = true;
           break;
         }
 
@@ -616,8 +618,10 @@ template <typename IRBuilder> class EVMByteCodeVisitor {
         }
 
         default:
-          throw getErrorWithExtraMessage(ErrorCode::UnsupportedOpcode,
-                                         std::to_string(Opcode));
+          // Treat as undefined
+          handleEndBlock();
+          Builder.handleUndefined();
+          InDeadCode = true;
         }
         PC++; // offset 1 byte for opcode
       }

src/compiler/evm_frontend/evm_analyzer.h

@@ -99,6 +99,7 @@ class EVMAnalyzer {
       case OP_TLOAD:
       case OP_BALANCE:
       case OP_SLOAD:
+      case OP_BLOBHASH:
         PopCount = 1;
         PushCount = 1;
         break;
@@ -273,8 +274,11 @@ class EVMAnalyzer {
       case OP_EXTCODECOPY:
         PopCount = 4;
         break;
+      case OP_JUMPDEST:
+        break;
       default:
-        // For unhandled opcodes, assume no stack change
+        // For unhandled opcodes, treat as invalid
+        Opcode = OP_INVALID;
         break;
       }
 
@@ -291,9 +295,9 @@ class EVMAnalyzer {
       // Check if this is a block starting opcode
       bool IsBlockStart = (Opcode == OP_JUMPDEST || Opcode == OP_JUMPI);
       // Check if this is a block ending opcode
-      bool IsBlockEnd =
-          (Opcode == OP_JUMP || Opcode == OP_RETURN || Opcode == OP_STOP ||
-           Opcode == OP_INVALID || Opcode == OP_REVERT);
+      bool IsBlockEnd = (Opcode == OP_JUMP || Opcode == OP_RETURN ||
+                         Opcode == OP_STOP || Opcode == OP_INVALID ||
+                         Opcode == OP_REVERT || Opcode == OP_SELFDESTRUCT);
 
       if (IsBlockStart) {
         if (PC != CurInfo.EntryPC) {

src/compiler/evm_frontend/evm_imported.cpp

@@ -111,6 +111,7 @@ const RuntimeFunctions &getRuntimeFunctionTable() {
       .HandleStaticCall = &evmHandleStaticCall,
       .SetRevert = &evmSetRevert,
       .HandleInvalid = &evmHandleInvalid,
+      .HandleUndefined = &evmHandleUndefined,
       .HandleSelfDestruct = &evmHandleSelfDestruct,
       .GetKeccak256 = &evmGetKeccak256};
   return Table;
@@ -997,14 +998,23 @@ uint64_t evmHandleCallCode(zen::runtime::EVMInstance *Instance, uint64_t Gas,
 }
 
 void evmHandleInvalid(zen::runtime::EVMInstance *Instance) {
-  // Immediately terminate the execution and return the revert code (2)
+  // Immediately terminate the execution and return the invalid code (4)
   evmc::Result ExeResult(
       EVMC_INVALID_INSTRUCTION, 0, Instance ? Instance->getGasRefund() : 0,
       Instance->getReturnData().data(), Instance->getReturnData().size());
   Instance->setExeResult(std::move(ExeResult));
   Instance->exit(4);
 }
 
+void evmHandleUndefined(zen::runtime::EVMInstance *Instance) {
+  // Immediately terminate the execution and return the undefined code
+  evmc::Result ExeResult(
+      EVMC_UNDEFINED_INSTRUCTION, 0, Instance ? Instance->getGasRefund() : 0,
+      Instance->getReturnData().data(), Instance->getReturnData().size());
+  Instance->setExeResult(std::move(ExeResult));
+  Instance->exit(5);
+}
+
 uint64_t evmHandleDelegateCall(zen::runtime::EVMInstance *Instance,
                                uint64_t Gas, const uint8_t *ToAddr,
                                uint64_t ArgsOffset, uint64_t ArgsSize,

src/compiler/evm_frontend/evm_imported.h

@@ -136,6 +136,7 @@ struct RuntimeFunctions {
   DelegateCallFn HandleStaticCall;
   VoidWithUInt64UInt64Fn SetRevert;
   VoidFn HandleInvalid;
+  VoidFn HandleUndefined;
   VoidWithBytes32Fn HandleSelfDestruct;
   Bytes32WithUInt64UInt64Fn GetKeccak256;
 };
@@ -258,6 +259,7 @@ uint64_t evmHandleStaticCall(zen::runtime::EVMInstance *Instance, uint64_t Gas,
 void evmSetRevert(zen::runtime::EVMInstance *Instance, uint64_t Offset,
                   uint64_t Size);
 void evmHandleInvalid(zen::runtime::EVMInstance *Instance);
+void evmHandleUndefined(zen::runtime::EVMInstance *Instance);
 const uint8_t *evmGetKeccak256(zen::runtime::EVMInstance *Instance,
                                uint64_t Offset, uint64_t Length);
 const intx::uint256 *evmGetSLoad(zen::runtime::EVMInstance *Instance,

src/compiler/evm_frontend/evm_mir_compiler.cpp

@@ -1947,6 +1947,11 @@ void EVMMirBuilder::handleInvalid() {
   const auto &RuntimeFunctions = getRuntimeFunctionTable();
   callRuntimeFor(RuntimeFunctions.HandleInvalid);
 }
+
+void EVMMirBuilder::handleUndefined() {
+  const auto &RuntimeFunctions = getRuntimeFunctionTable();
+  callRuntimeFor(RuntimeFunctions.HandleUndefined);
+}
 typename EVMMirBuilder::Operand
 EVMMirBuilder::handleSLoad(Operand KeyComponents) {
   const auto &RuntimeFunctions = getRuntimeFunctionTable();

src/compiler/evm_frontend/evm_mir_compiler.h

@@ -397,6 +397,7 @@ class EVMMirBuilder final {
                            Operand RetOffsetOp, Operand RetSizeOp);
   void handleRevert(Operand OffsetOp, Operand SizeOp);
   void handleInvalid();
+  void handleUndefined();
   void handleTrap(ErrorCode ErrCode);
   Operand handleKeccak256(Operand OffsetComponents, Operand LengthComponents);
   Operand handleSLoad(Operand KeyComponents);