Add basic/untested support for Byzantium opcodes

Author: lrettig

include/evm2wasm.h

@@ -47,6 +47,8 @@ enum class opcodeEnum
     GASPRICE,
     EXTCODESIZE,
     EXTCODECOPY,
+    RETURNDATASIZE,
+    RETURNDATACOPY,
     BLOCKHASH,
     COINBASE,
     TIMESTAMP,
@@ -75,8 +77,9 @@ enum class opcodeEnum
     RETURN,
     DELEGATECALL,
     STATICCALL,
-    SELFDESTRUCT,
+    REVERT,
     INVALID,
+    SELFDESTRUCT,
     bswap_i32,
     bswap_i64,
     bswap_m128,
@@ -164,6 +167,8 @@ static std::map<int, std::tuple<opcodeEnum, int, int, int>> codes = {
     {0x3a, Opcode{opcodeEnum::GASPRICE, 0, 0, 1}},
     {0x3b, Opcode{opcodeEnum::EXTCODESIZE, 0, 1, 1}},
     {0x3c, Opcode{opcodeEnum::EXTCODECOPY, 0, 4, 0}},
+    {0x3d, Opcode{opcodeEnum::RETURNDATASIZE, 0, 0, 1}},
+    {0x3e, Opcode{opcodeEnum::RETURNDATACOPY, 0, 3, 0}},
 
     // "0x40" range - block operations
     {0x40, Opcode{opcodeEnum::BLOCKHASH, 0, 1, 1}},
@@ -270,6 +275,8 @@ static std::map<int, std::tuple<opcodeEnum, int, int, int>> codes = {
     {0xfa, Opcode{opcodeEnum::STATICCALL, 0, 6, 1}},
 
     // "0x70", range - other
+    {0xfd, Opcode{opcodeEnum::REVERT, 0, 2, 0}},
+    {0xfe, Opcode{opcodeEnum::INVALID, 0, 0, 0}},
     {0xff, Opcode{opcodeEnum::SELFDESTRUCT, 0, 1, 0}}};
 
 static std::map<opcodeEnum, std::vector<opcodeEnum>> depMap = {
@@ -306,6 +313,7 @@ static std::map<opcodeEnum, std::vector<opcodeEnum>> depMap = {
     {opcodeEnum::EXTCODECOPY, {opcodeEnum::bswap_m256, opcodeEnum::callback, opcodeEnum::memusegas,
                                   opcodeEnum::check_overflow, opcodeEnum::memset}},
     {opcodeEnum::EXTCODESIZE, {opcodeEnum::callback_32, opcodeEnum::bswap_m256}},
+    {opcodeEnum::RETURNDATACOPY, {opcodeEnum::memusegas, opcodeEnum::check_overflow, opcodeEnum::memset}},
     {opcodeEnum::LOG, {opcodeEnum::memusegas, opcodeEnum::check_overflow}},
     {opcodeEnum::BLOCKHASH, {opcodeEnum::check_overflow, opcodeEnum::callback_256}},
     {opcodeEnum::SHA3, {opcodeEnum::memusegas, opcodeEnum::bswap_m256, opcodeEnum::check_overflow,
@@ -326,6 +334,7 @@ static std::map<opcodeEnum, std::vector<opcodeEnum>> depMap = {
     {opcodeEnum::CREATE, {opcodeEnum::bswap_m256, opcodeEnum::bswap_m160, opcodeEnum::callback_160,
                              opcodeEnum::memusegas, opcodeEnum::check_overflow}},
     {opcodeEnum::RETURN, {opcodeEnum::memusegas, opcodeEnum::check_overflow}},
+    {opcodeEnum::REVERT, {opcodeEnum::memusegas, opcodeEnum::check_overflow}},
     {opcodeEnum::BALANCE, {opcodeEnum::bswap_m256, opcodeEnum::callback_128}},
     {opcodeEnum::SELFDESTRUCT, {opcodeEnum::bswap_m256}},
     {opcodeEnum::SSTORE, {opcodeEnum::bswap_m256, opcodeEnum::callback}},

index.js

@@ -34,6 +34,7 @@ const depMap = new Map([
   ['CALLVALUE', ['bswap_m128']],
   ['EXTCODECOPY', ['bswap_m256', 'callback', 'memusegas', 'check_overflow', 'memset']],
   ['EXTCODESIZE', ['callback_32', 'bswap_m256']],
+  ['RETURNDATACOPY', ['memusegas', 'check_overflow', 'memset']],
   ['LOG', ['memusegas', 'check_overflow']],
   ['BLOCKHASH', ['check_overflow', 'callback_256']],
   ['SHA3', ['memusegas', 'bswap_m256', 'check_overflow', 'keccak']],
@@ -43,6 +44,7 @@ const depMap = new Map([
   ['CALLCODE', ['bswap_m256', 'callback', 'memusegas', 'check_overflow_i64', 'check_overflow', 'check_overflow_i64', 'memset', 'callback_32']],
   ['CREATE', ['bswap_m256', 'bswap_m160', 'callback_160', 'memusegas', 'check_overflow']],
   ['RETURN', ['memusegas', 'check_overflow']],
+  ['REVERT', ['memusegas', 'check_overflow']],
   ['BALANCE', ['bswap_m256', 'callback_128']],
   ['SELFDESTRUCT', ['bswap_m256']],
   ['SSTORE', ['bswap_m256', 'callback']],
@@ -299,6 +301,7 @@ exports.evm2wast = function (evmCode, opts = {
         break
       case 'SELFDESTRUCT':
       case 'RETURN':
+      case 'REVERT':
         segment += `(call $${op.name}) (br $done)\n`
         if (jumpFound) {
           pc = findNextJumpDest(evmCode, pc)

libs/evm2wasm/evm2wasm.cpp

@@ -318,6 +318,7 @@ string evm2wast(const vector<uint8_t>& evmCode, bool stackTrace, bool useAsyncAP
             break;
         case opcodeEnum::SELFDESTRUCT:
         case opcodeEnum::RETURN:
+        case opcodeEnum::REVERT:
             segment << "(call $" << opcodeToString(op.name) << ") (br $done)\n";
             if (jumpFound)
             {

opcodes.js

@@ -44,6 +44,8 @@ const codes = {
   0x3a: ['GASPRICE', 0, 0, 1],
   0x3b: ['EXTCODESIZE', 0, 1, 1],
   0x3c: ['EXTCODECOPY', 0, 4, 0],
+  0x3d: ['RETURNDATASIZE', 0, 0, 1],
+  0x3e: ['RETURNDATACOPY', 0, 3, 0],
 
   // '0x40' range - block operations
   0x40: ['BLOCKHASH', 0, 1, 1],
@@ -150,11 +152,14 @@ const codes = {
   0xfa: ['STATICCALL', 0, 6, 1],
 
   // '0x70', range - other
+  0xfd: ['REVERT', 0, 2, 0],
+  0xfe: ['INVALID', 0, 0, 0],
   0xff: ['SELFDESTRUCT', 0, 1, 0]
 }
 
 module.exports = function (op) {
-  const code = codes[op] ? codes[op] : ['INVALID', 0, 0, 0]
+  // Map invalid opcodes to the INVALID opcode
+  const code = codes[op] ? codes[op] : codes[0xfe]
   let opcode = code[0]
   let number
 

wasm/generateInterface.js

@@ -161,6 +161,16 @@ const interfaceManifest = {
     input: ['gasLimit', 'address', 'readOffset', 'length'],
     output: ['i32']
   },
+  RETURNDATACOPY: {
+    name: 'returnDataCopy',
+    input: ['writeOffset', 'i32', 'length'],
+    output: []
+  },
+  RETURNDATASIZE: {
+    name: 'getReturnDataSize',
+    input: [],
+    output: ['i32']
+  },
   SSTORE: {
     name: 'storageStore',
     async: true,
@@ -182,6 +192,11 @@ const interfaceManifest = {
     name: 'return',
     input: ['readOffset', 'length'],
     output: []
+  },
+  REVERT: {
+    name: 'revert',
+    input: ['readOffset', 'length'],
+    output: []
   }
 }