status-im/evmc
2
0
Fork 0
mirror of https://github.com/status-im/evmc.git synced 2025-02-24 00:48:09 +00:00
Code Issues Projects Releases Wiki Activity

instructions: Set gas cost for undefined instructions to 0

Browse Source
This commit is contained in:
Paweł Bylica 2019-09-19 15:36:35 +02:00
parent 3ae155fdee
commit e87b24dfe1
No known key found for this signature in database
GPG Key ID: 7A0C037434FE77EF
3 changed files with 19 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/evmc/instructions.h
View File

@ -181,11 +181,11 @@ enum evmc_opcode
/** /**
* Metrics for an EVM 1 instruction. * Metrics for an EVM 1 instruction.
* *
* Small integer types are used here to make the tables of metrics cache friendly. * Small integer types are used here to make the tables of metrics smaller.
*/ */
struct evmc_instruction_metrics struct evmc_instruction_metrics
{ {
/** The instruction gas cost. Value -1 indicates an undefined instruction. */ /** The instruction gas cost. */
int16_t gas_cost; int16_t gas_cost;
/** The number of items the instruction pops from the EVM stack before execution. */ /** The number of items the instruction pops from the EVM stack before execution. */

9
lib/instructions/instruction_metrics.c
View File

@ -5,8 +5,13 @@
#include <evmc/instructions.h> #include <evmc/instructions.h>
/** Marks an instruction as undefined. */ /**
#define UNDEFINED -1 * Marks an instruction as undefined.
*
* The gas cost for undefined instructions is 0 because this is the cost of executing them
* in practice in EVM implementations.
*/
#define UNDEFINED 0
/** /**
* Gas price tiers, names from Yellow Paper. * Gas price tiers, names from Yellow Paper.

20
test/unittests/test_instructions.cpp
View File

@ -28,7 +28,7 @@ TEST(instructions, name_gas_cost_equivalence)
if (name != nullptr) if (name != nullptr)
EXPECT_GE(gas_cost, 0); EXPECT_GE(gas_cost, 0);
else else
EXPECT_EQ(gas_cost, -1); EXPECT_EQ(gas_cost, 0);
} }
} }
} }
@ -53,7 +53,7 @@ TEST(instructions, homestead_hard_fork)
} }
} }
EXPECT_EQ(f[OP_DELEGATECALL].gas_cost, -1); EXPECT_EQ(f[OP_DELEGATECALL].gas_cost, 0);
EXPECT_EQ(h[OP_DELEGATECALL].gas_cost, 40); EXPECT_EQ(h[OP_DELEGATECALL].gas_cost, 40);
EXPECT_TRUE(fn[OP_DELEGATECALL] == nullptr); EXPECT_TRUE(fn[OP_DELEGATECALL] == nullptr);
EXPECT_EQ(hn[OP_DELEGATECALL], std::string{"DELEGATECALL"}); EXPECT_EQ(hn[OP_DELEGATECALL], std::string{"DELEGATECALL"});
@ -161,22 +161,22 @@ TEST(instructions, byzantium_hard_fork)
EXPECT_EQ(b[OP_REVERT].gas_cost, 0); EXPECT_EQ(b[OP_REVERT].gas_cost, 0);
EXPECT_EQ(b[OP_REVERT].num_stack_arguments, 2); EXPECT_EQ(b[OP_REVERT].num_stack_arguments, 2);
EXPECT_EQ(b[OP_REVERT].num_stack_returned_items, 0); EXPECT_EQ(b[OP_REVERT].num_stack_returned_items, 0);
EXPECT_EQ(sd[OP_REVERT].gas_cost, -1); EXPECT_EQ(sd[OP_REVERT].gas_cost, 0);
EXPECT_EQ(bn[OP_REVERT], std::string{"REVERT"}); EXPECT_EQ(bn[OP_REVERT], std::string{"REVERT"});
EXPECT_TRUE(sdn[OP_REVERT] == nullptr); EXPECT_TRUE(sdn[OP_REVERT] == nullptr);
EXPECT_EQ(b[OP_RETURNDATACOPY].gas_cost, 3); EXPECT_EQ(b[OP_RETURNDATACOPY].gas_cost, 3);
EXPECT_EQ(sd[OP_RETURNDATACOPY].gas_cost, -1); EXPECT_EQ(sd[OP_RETURNDATACOPY].gas_cost, 0);
EXPECT_EQ(bn[OP_RETURNDATACOPY], std::string{"RETURNDATACOPY"}); EXPECT_EQ(bn[OP_RETURNDATACOPY], std::string{"RETURNDATACOPY"});
EXPECT_TRUE(sdn[OP_RETURNDATACOPY] == nullptr); EXPECT_TRUE(sdn[OP_RETURNDATACOPY] == nullptr);
EXPECT_EQ(b[OP_RETURNDATASIZE].gas_cost, 2); EXPECT_EQ(b[OP_RETURNDATASIZE].gas_cost, 2);
EXPECT_EQ(sd[OP_RETURNDATASIZE].gas_cost, -1); EXPECT_EQ(sd[OP_RETURNDATASIZE].gas_cost, 0);
EXPECT_EQ(bn[OP_RETURNDATASIZE], std::string{"RETURNDATASIZE"}); EXPECT_EQ(bn[OP_RETURNDATASIZE], std::string{"RETURNDATASIZE"});
EXPECT_TRUE(sdn[OP_RETURNDATASIZE] == nullptr); EXPECT_TRUE(sdn[OP_RETURNDATASIZE] == nullptr);
EXPECT_EQ(b[OP_STATICCALL].gas_cost, 700); EXPECT_EQ(b[OP_STATICCALL].gas_cost, 700);
EXPECT_EQ(sd[OP_STATICCALL].gas_cost, -1); EXPECT_EQ(sd[OP_STATICCALL].gas_cost, 0);
EXPECT_EQ(bn[OP_STATICCALL], std::string{"STATICCALL"}); EXPECT_EQ(bn[OP_STATICCALL], std::string{"STATICCALL"});
EXPECT_TRUE(sdn[OP_STATICCALL] == nullptr); EXPECT_TRUE(sdn[OP_STATICCALL] == nullptr);
} }
@ -216,14 +216,14 @@ TEST(instructions, constantinople_hard_fork)
EXPECT_EQ(c[OP_CREATE2].gas_cost, 32000); EXPECT_EQ(c[OP_CREATE2].gas_cost, 32000);
EXPECT_EQ(c[OP_CREATE2].num_stack_arguments, 4); EXPECT_EQ(c[OP_CREATE2].num_stack_arguments, 4);
EXPECT_EQ(c[OP_CREATE2].num_stack_returned_items, 1); EXPECT_EQ(c[OP_CREATE2].num_stack_returned_items, 1);
EXPECT_EQ(b[OP_CREATE2].gas_cost, -1); EXPECT_EQ(b[OP_CREATE2].gas_cost, 0);
EXPECT_EQ(cn[OP_CREATE2], std::string{"CREATE2"}); EXPECT_EQ(cn[OP_CREATE2], std::string{"CREATE2"});
EXPECT_TRUE(bn[OP_CREATE2] == nullptr); EXPECT_TRUE(bn[OP_CREATE2] == nullptr);
EXPECT_EQ(c[OP_EXTCODEHASH].gas_cost, 400); EXPECT_EQ(c[OP_EXTCODEHASH].gas_cost, 400);
EXPECT_EQ(c[OP_EXTCODEHASH].num_stack_arguments, 1); EXPECT_EQ(c[OP_EXTCODEHASH].num_stack_arguments, 1);
EXPECT_EQ(c[OP_EXTCODEHASH].num_stack_returned_items, 1); EXPECT_EQ(c[OP_EXTCODEHASH].num_stack_returned_items, 1);
EXPECT_EQ(b[OP_EXTCODEHASH].gas_cost, -1); EXPECT_EQ(b[OP_EXTCODEHASH].gas_cost, 0);
EXPECT_EQ(cn[OP_EXTCODEHASH], std::string{"EXTCODEHASH"}); EXPECT_EQ(cn[OP_EXTCODEHASH], std::string{"EXTCODEHASH"});
EXPECT_TRUE(bn[OP_EXTCODEHASH] == nullptr); EXPECT_TRUE(bn[OP_EXTCODEHASH] == nullptr);
} }
@ -269,14 +269,14 @@ TEST(instructions, istanbul_hard_fork)
EXPECT_EQ(i[OP_CHAINID].gas_cost, 2); EXPECT_EQ(i[OP_CHAINID].gas_cost, 2);
EXPECT_EQ(i[OP_CHAINID].num_stack_arguments, 0); EXPECT_EQ(i[OP_CHAINID].num_stack_arguments, 0);
EXPECT_EQ(i[OP_CHAINID].num_stack_returned_items, 1); EXPECT_EQ(i[OP_CHAINID].num_stack_returned_items, 1);
EXPECT_EQ(p[OP_CHAINID].gas_cost, -1); EXPECT_EQ(p[OP_CHAINID].gas_cost, 0);
EXPECT_EQ(in[OP_CHAINID], std::string{"CHAINID"}); EXPECT_EQ(in[OP_CHAINID], std::string{"CHAINID"});
EXPECT_TRUE(pn[OP_CHAINID] == nullptr); EXPECT_TRUE(pn[OP_CHAINID] == nullptr);
EXPECT_EQ(i[OP_SELFBALANCE].gas_cost, 5); EXPECT_EQ(i[OP_SELFBALANCE].gas_cost, 5);
EXPECT_EQ(i[OP_SELFBALANCE].num_stack_arguments, 0); EXPECT_EQ(i[OP_SELFBALANCE].num_stack_arguments, 0);
EXPECT_EQ(i[OP_SELFBALANCE].num_stack_returned_items, 1); EXPECT_EQ(i[OP_SELFBALANCE].num_stack_returned_items, 1);
EXPECT_EQ(p[OP_SELFBALANCE].gas_cost, -1); EXPECT_EQ(p[OP_SELFBALANCE].gas_cost, 0);
EXPECT_EQ(in[OP_SELFBALANCE], std::string{"SELFBALANCE"}); EXPECT_EQ(in[OP_SELFBALANCE], std::string{"SELFBALANCE"});
EXPECT_TRUE(pn[OP_SELFBALANCE] == nullptr); EXPECT_TRUE(pn[OP_SELFBALANCE] == nullptr);