status-im/evmc
2
0
Fork 0
mirror of https://github.com/status-im/evmc.git synced 2025-02-23 08:28:15 +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.
*
* 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
{
/** The instruction gas cost. Value -1 indicates an undefined instruction. */
/** The instruction gas cost. */
int16_t gas_cost;
/** 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>
/** 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.

20
test/unittests/test_instructions.cpp
View File

@ -28,7 +28,7 @@ TEST(instructions, name_gas_cost_equivalence)
if (name != nullptr)
EXPECT_GE(gas_cost, 0);
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_TRUE(fn[OP_DELEGATECALL] == nullptr);
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].num_stack_arguments, 2);
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_TRUE(sdn[OP_REVERT] == nullptr);
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_TRUE(sdn[OP_RETURNDATACOPY] == nullptr);
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_TRUE(sdn[OP_RETURNDATASIZE] == nullptr);
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_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].num_stack_arguments, 4);
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_TRUE(bn[OP_CREATE2] == nullptr);
EXPECT_EQ(c[OP_EXTCODEHASH].gas_cost, 400);
EXPECT_EQ(c[OP_EXTCODEHASH].num_stack_arguments, 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_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].num_stack_arguments, 0);
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_TRUE(pn[OP_CHAINID] == nullptr);
EXPECT_EQ(i[OP_SELFBALANCE].gas_cost, 5);
EXPECT_EQ(i[OP_SELFBALANCE].num_stack_arguments, 0);
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_TRUE(pn[OP_SELFBALANCE] == nullptr);