Merge pull request #138 from ethereum/fix_conversion_warnings

Fix conversion warnings

Author: chfast

CMakeLists.txt

@@ -33,7 +33,7 @@ find_package(ethash CONFIG REQUIRED)
 option(EVMC_TEST_TOOLS "Build EVMC test tools" ${EVMONE_TESTING})
 add_subdirectory(evmc)
 
-cable_configure_compiler(NO_PEDANTIC NO_CONVERSION_WARNINGS)
+cable_configure_compiler()
 if(CABLE_COMPILER_GNULIKE)
     add_compile_options(-Wno-attributes)  # Allow using unknown attributes.
 

lib/evmone/analysis.cpp

@@ -15,6 +15,7 @@ inline constexpr evmc_call_kind op2call_kind(uint8_t opcode) noexcept
 {
     switch (opcode)
     {
+    default:
     case OP_CREATE:
         return EVMC_CREATE;
     case OP_CALL:
@@ -25,8 +26,6 @@ inline constexpr evmc_call_kind op2call_kind(uint8_t opcode) noexcept
         return EVMC_DELEGATECALL;
     case OP_CREATE2:
         return EVMC_CREATE2;
-    default:
-        return evmc_call_kind(-1);
     }
 }
 

lib/evmone/analysis.hpp

@@ -196,7 +196,9 @@ inline int find_jumpdest(const code_analysis& analysis, int offset) noexcept
     const auto begin = std::begin(analysis.jumpdest_offsets);
     const auto end = std::end(analysis.jumpdest_offsets);
     const auto it = std::lower_bound(begin, end, offset);
-    return (it != end && *it == offset) ? analysis.jumpdest_targets[it - begin] : -1;
+    return (it != end && *it == offset) ?
+               analysis.jumpdest_targets[static_cast<size_t>(it - begin)] :
+               -1;
 }
 
 EVMC_EXPORT code_analysis analyze(

lib/evmone/instructions.cpp

@@ -21,25 +21,25 @@ constexpr auto word_size = 32;
 
 /// Returns number of words what would fit to provided number of bytes,
 /// i.e. it rounds up the number bytes to number of words.
-constexpr int64_t num_words(size_t size_in_bytes) noexcept
+constexpr int64_t num_words(uint64_t size_in_bytes) noexcept
 {
     return (static_cast<int64_t>(size_in_bytes) + (word_size - 1)) / word_size;
 }
 
-inline bool check_memory(execution_state& state, const uint256& offset, int64_t size) noexcept
+inline bool check_memory(execution_state& state, const uint256& offset, uint64_t size) noexcept
 {
     if (offset > max_buffer_size)
     {
         state.exit(EVMC_OUT_OF_GAS);
         return false;
     }
 
-    const auto new_size = static_cast<int64_t>(offset) + size;
-    const auto current_size = static_cast<int64_t>(state.memory.size());
+    const auto new_size = static_cast<uint64_t>(offset) + size;
+    const auto current_size = state.memory.size();
     if (new_size > current_size)
     {
         const auto new_words = num_words(new_size);
-        const auto current_words = current_size / 32;  // Memory always has full words.
+        const auto current_words = static_cast<int64_t>(current_size / 32);
         const auto new_cost = 3 * new_words + new_words * new_words / 512;
         const auto current_cost = 3 * current_words + current_words * current_words / 512;
         const auto cost = new_cost - current_cost;
@@ -68,7 +68,7 @@ inline bool check_memory(
         return false;
     }
 
-    return check_memory(state, offset, static_cast<int64_t>(size));
+    return check_memory(state, offset, static_cast<uint64_t>(size));
 }
 
 
@@ -144,7 +144,8 @@ void op_exp(execution_state& state, instr_argument) noexcept
     const auto base = state.stack.pop();
     auto& exponent = state.stack.top();
 
-    const auto exponent_significant_bytes = intx::count_significant_words<uint8_t>(exponent);
+    const auto exponent_significant_bytes =
+        static_cast<int>(intx::count_significant_words<uint8_t>(exponent));
     const auto exponent_cost = state.rev >= EVMC_SPURIOUS_DRAGON ? 50 : 10;
     const auto additional_cost = exponent_significant_bytes * exponent_cost;
     if ((state.gas_left -= additional_cost) < 0)

test/bench/CMakeLists.txt

@@ -29,7 +29,7 @@ if(NOT HAVE_FILESYSTEM)
         INSTALL_COMMAND ""
     )
 
-    target_include_directories(evmone-bench PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_include_directories(evmone-bench SYSTEM PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
     add_dependencies(evmone-bench ghcfilesystem)
 elseif(UNIX AND NOT APPLE)
     target_link_libraries(evmone-bench PRIVATE stdc++fs)

test/bench/bench.cpp

@@ -65,7 +65,7 @@ constexpr auto fn_table = evmone::exec_fn_table{};
 
 void analyse(State& state, bytes_view code) noexcept
 {
-    auto bytes_analysed = int64_t{0};
+    auto bytes_analysed = uint64_t{0};
     for (auto _ : state)
     {
         auto r = evmone::analyze(fn_table, EVMC_PETERSBURG, code.data(), code.size());

test/unittests/evm_test.cpp

@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <numeric>
 
+using namespace evmc::literals;
 using namespace intx;
 
 constexpr auto max_code_size = 0x6000;
@@ -755,7 +756,7 @@ TEST_F(evm, log)
         EXPECT_EQ(last_log.data[0], 0x77);
         EXPECT_EQ(last_log.data[1], 0);
         ASSERT_EQ(last_log.topics.size(), n);
-        for (int i = 0; i < n; ++i)
+        for (size_t i = 0; i < static_cast<size_t>(n); ++i)
         {
             EXPECT_EQ(last_log.topics[i].bytes[31], 4 - i);
         }
@@ -904,7 +905,7 @@ TEST_F(evm, extcode)
 {
     auto addr = evmc_address{};
     std::fill(std::begin(addr.bytes), std::end(addr.bytes), uint8_t{0xff});
-    addr.bytes[19] -= 1;
+    addr.bytes[19]--;
 
     accounts[addr].code = {'a', 'b', 'c', 'd'};
 
@@ -1179,9 +1180,8 @@ TEST_F(evm, extcodecopy_memory_cost)
 
 TEST_F(evm, extcodecopy_nonzero_index)
 {
-    auto addr = evmc_address{};
-    addr.bytes[19] = 0xa;
-    auto index = 15;
+    constexpr auto addr = 0x000000000000000000000000000000000000000a_address;
+    constexpr auto index = 15;
 
     auto& extcode = accounts[addr].code;
     extcode.assign(16, 0x00);

test/utils/host_mock.hpp

@@ -125,7 +125,7 @@ class MockedHost : public evmc::Host
         record_account_access(addr);
         const auto it = accounts.find(addr);
         if (it == accounts.end())
-            return static_cast<evmc_storage_status>(-1);
+            return EVMC_STORAGE_UNCHANGED;
 
         auto& old = it->second.storage[key];
 

test/utils/utils.cpp

@@ -50,7 +50,7 @@ bytes from_hexx(const std::string& hexx)
     const auto re = std::regex{R"(\((\d+)x([^)]+)\))"};
 
     auto hex = hexx;
-    auto position_correction = int{0};
+    auto position_correction = size_t{0};
     for (auto it = std::sregex_iterator{hexx.begin(), hexx.end(), re}; it != std::sregex_iterator{};
          ++it)
     {
@@ -59,8 +59,10 @@ bytes from_hexx(const std::string& hexx)
         while (num_repetitions-- > 0)
             replacement += (*it)[2];
 
-        hex.replace(it->position() + position_correction, it->length(), replacement);
-        position_correction += static_cast<int>(replacement.length() - it->length());
+        const auto pos = static_cast<size_t>(it->position()) + position_correction;
+        const auto length = static_cast<size_t>(it->length());
+        hex.replace(pos, length, replacement);
+        position_correction += replacement.length() - length;
     }
     return from_hex(hex);
 }