diff --git a/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm b/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm index bda6f96e..56d9e126 100644 --- a/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm +++ b/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm @@ -4,8 +4,9 @@ global jumpdest_analysis: // stack: ctx, code_len, retdest PUSH 0 // i = 0 + %stack (i, ctx, code_len, retdest) -> (i, ctx, code_len, retdest, 0) // ctr -loop: +global loop: // stack: i, ctx, code_len, retdest // Ideally we would break if i >= code_len, but checking i > code_len is // cheaper. It doesn't hurt to over-read by 1, since we'll read 0 which is @@ -13,6 +14,20 @@ loop: DUP3 DUP2 GT // i > code_len %jumpi(return) + %stack (i, ctx) -> (ctx, @SEGMENT_CODE, i, 32, i, ctx) + %mload_packing + // stack: packed_opcodes + DUP1 + PUSH 0x8080808080808080808080808080808080808080808080808080808080808080 + AND +global debug_before_as_dad: + %jumpi(as_dad) +global debug_wuau: +as_dad: + POP +global debug_not_wuau: + + // stack: i, ctx, code_len, retdest %stack (i, ctx) -> (ctx, @SEGMENT_CODE, i, i, ctx) MLOAD_GENERAL @@ -28,8 +43,11 @@ loop: // stack: JUMPDEST, i, ctx, code_len, retdest %stack (JUMPDEST, i, ctx) -> (1, ctx, @SEGMENT_JUMPDEST_BITS, i, JUMPDEST, i, ctx) MSTORE_GENERAL + %stack (opcode, i, ctx, code_len, retdest, ctr) -> (ctr, opcode, i, ctx, code_len, retdest) + %increment + %stack (ctr, opcode, i, ctx, code_len, retdest) -> (opcode, i, ctx, code_len, retdest, ctr) -continue: +global continue: // stack: opcode, i, ctx, code_len, retdest %add_const(code_bytes_to_skip) %mload_kernel_code @@ -38,9 +56,12 @@ continue: // stack: i, ctx, code_len, retdest %jump(loop) -return: +global return: // stack: i, ctx, code_len, retdest %pop3 + SWAP1 +global debug_ctr: + POP JUMP // Determines how many bytes away is the next opcode, based on the opcode we read. @@ -48,7 +69,7 @@ return: // // Note that the range of PUSH opcodes is [0x60, 0x80). I.e. PUSH1 is 0x60 // and PUSH32 is 0x7f. -code_bytes_to_skip: +global code_bytes_to_skip: %rep 96 BYTES 1 // 0x00-0x5f %endrep diff --git a/evm/src/cpu/kernel/asm/main.asm b/evm/src/cpu/kernel/asm/main.asm index b495d499..f6cd03bc 100644 --- a/evm/src/cpu/kernel/asm/main.asm +++ b/evm/src/cpu/kernel/asm/main.asm @@ -13,6 +13,9 @@ global main: // Initialise the shift table %shift_table_init + + // Encode constant nodes + %initialize_rlp_segment // Initialize the state, transaction and receipt trie root pointers. PROVER_INPUT(trie_ptr::state) diff --git a/evm/src/cpu/kernel/asm/mpt/hash/hash.asm b/evm/src/cpu/kernel/asm/mpt/hash/hash.asm index df7e1d74..3bbb84f3 100644 --- a/evm/src/cpu/kernel/asm/mpt/hash/hash.asm +++ b/evm/src/cpu/kernel/asm/mpt/hash/hash.asm @@ -92,9 +92,9 @@ maybe_hash_node: KECCAK_GENERAL %stack (hash, cur_len, retdest) -> (retdest, hash, 32, cur_len) JUMP -pack_small_rlp: - // stack: result_ptr, result_len, cur_len, retdest - %stack (result_ptr, result_len, cur_len) +global pack_small_rlp: + // stack: result_ptr, result_len, retdest + %stack (result_ptr, result_len) -> (0, @SEGMENT_RLP_RAW, result_ptr, result_len, after_packed_small_rlp, result_len, cur_len) %jump(mload_packing) @@ -105,10 +105,10 @@ after_packed_small_rlp: // RLP encode the given trie node, and return an (pointer, length) pair // indicating where the data lives within @SEGMENT_RLP_RAW. // -// Pre stack: node_type, node_ptr, encode_value, cur_len, retdest -// Post stack: result_ptr, result_len, cur_len -encode_node: - // stack: node_type, node_ptr, encode_value, cur_len, retdest +// Pre stack: node_type, node_ptr, encode_value, retdest +// Post stack: result_ptr, result_len +global encode_node: + // stack: node_type, node_ptr, encode_value, retdest // Increment node_ptr, so it points to the node payload instead of its type. SWAP1 %increment SWAP1 // stack: node_type, node_payload_ptr, encode_value, cur_len, retdest @@ -123,20 +123,13 @@ encode_node: PANIC global encode_node_empty: - // stack: node_type, node_payload_ptr, encode_value, cur_len, retdest - // Then length of `TrieData` is unchanged here. + // stack: node_type, node_payload_ptr, encode_value, retdest %pop3 - // stack: cur_len, retdest - // An empty node is encoded as a single byte, 0x80, which is the RLP encoding of the empty string. - // TODO: Write this byte just once to RLP memory, then we can always return (0, 1). - %alloc_rlp_block - // stack: rlp_pos, cur_len, retdest - PUSH 0x80 - // stack: 0x80, rlp_pos, cur_len, retdest - DUP2 - // stack: rlp_pos, 0x80, rlp_pos, cur_len, retdest - %mstore_rlp - %stack (rlp_pos, cur_len, retdest) -> (retdest, rlp_pos, 1, cur_len) + PUSH 0x1000 + %mload_kernel(@SEGMENT_RLP_RAW) +global debug_it_should_be_128: + POP + %stack (retdest) -> (retdest, 0x1000, 1) JUMP global encode_node_branch: @@ -329,3 +322,81 @@ encode_node_leaf_after_encode_value: %stack (rlp_prefix_start_pos, rlp_len, cur_len, retdest) -> (retdest, rlp_prefix_start_pos, rlp_len, cur_len) JUMP + +global encode_node_branch_new: + // stack: node_type, node_payload_ptr, encode_value, retdest + POP + // stack: node_payload_ptr, encode_value, retdest + + //Allocate a block of RLP memory + %alloc_rlp_block DUP1 + // stack: rlp_pos, node_payload_ptr, encode_value, retdest + + // Call encode_or_hash_node on each child + %encode_child_new(0) %encode_child_new(1) %encode_child_new(2) %encode_child_new(3) + %encode_child_new(4) %encode_child_new(5) %encode_child_new(6) %encode_child_new(7) + %encode_child_new(8) %encode_child_new(9) %encode_child_new(10) %encode_child_new(11) + %encode_child_new(12) %encode_child_new(13) %encode_child_new(14) %encode_child_new(15) + + // stack: rlp_pos', rlp_start, node_payload_ptr, encode_value, retdest + + %stack (rlp_pos, rlp_start, node_payload_ptr) + -> (node_payload_ptr, rlp_pos, rlp_start) + %add_const(16) + // stack: value_ptr_ptr, rlp_pos', rlp_start, encode_value, retdest + %mload_trie_data + // stack: value_ptr, rlp_pos', rlp_start, encode_value, retdest + DUP1 %jumpi(encode_node_branch_with_value_new) + + // No value; append the empty string (0x80). + // stack: value_ptr, rlp_pos', rlp_start, encode_value, retdest + %stack (value_ptr, rlp_pos, rlp_start, encode_value) -> (rlp_pos, 0x80, rlp_pos, rlp_start) + %mstore_rlp + // stack: rlp_pos', rlp_start, retdest + %increment + // stack: rlp_pos'', rlp_start, retdest + %jump(encode_node_branch_prepend_prefix_new) +encode_node_branch_with_value_new: + // stack: value_ptr, rlp_pos', rlp_start, encode_value, retdest + %stack (value_ptr, rlp_pos, rlp_start, encode_value) + -> (encode_value, rlp_pos, value_ptr, encode_node_branch_prepend_prefix, rlp_start) + JUMP // call encode_value +encode_node_branch_prepend_prefix_new: + // stack: rlp_pos'', rlp_start, retdest + %prepend_rlp_list_prefix + // stack: rlp_prefix_start, rlp_len, retdest + %stack (rlp_prefix_start, rlp_len, retdest) + -> (retdest, rlp_prefix_start, rlp_len) + JUMP + + +// Part of the encode_node_branch function. Encodes the i'th child. +// Stores the result in SEGMENT_TRIE_ENCODED_CHILD[base + i], and its length in +// SEGMENT_TRIE_ENCODED_CHILD_LEN[base + i]. +%macro encode_child_new(i) + // stack: rlp_pos, rlp_start, node_payload_ptr, encode_value, retdest + PUSH %%after_encode + DUP5 DUP5 + // stack: node_payload_ptr, encode_value, %%after_encode, rlp_pos, rlp_start, node_payload_ptr, encode_value, retdest + %add_const($i) %mload_trie_data + // stack: child_i_ptr, encode_value, %%after_encode, rlp_pos, rlp_start, node_payload_ptr, encode_value, retdest + %jump(encode_or_hash_node) +%%after_encode: + // stack: result, result_len, rlp_pos, rlp_start, node_payload_ptr, encode_value, retdest + // If result_len != 32, result is raw RLP, with an appropriate RLP prefix already. + SWAP1 DUP1 %sub_const(32) %jumpi(%%unpack) + // Otherwise, result is a hash, and we need to add the prefix 0x80 + 32 = 160. + // stack: result_len, result, rlp_pos, rlp_start, node_payload_ptr, encode_value, retdest + PUSH 160 + DUP4 // rlp_pos + %mstore_rlp + SWAP2 %increment SWAP2 // rlp_pos += 1 +%%unpack: + %stack (result_len, result, rlp_pos, rlp_start, node_payload_ptr, encode_value, retdest) + -> (rlp_pos, result, result_len, %%after_unpacking, + rlp_start, node_payload_ptr, encode_value, retdest) + %jump(mstore_unpacking_rlp) +%%after_unpacking: + // stack: rlp_pos', rlp_start, node_payload_ptr, encode_value, retdest +%endmacro + diff --git a/evm/src/cpu/kernel/asm/mpt/util.asm b/evm/src/cpu/kernel/asm/mpt/util.asm index 80e5c6f7..b492a0d0 100644 --- a/evm/src/cpu/kernel/asm/mpt/util.asm +++ b/evm/src/cpu/kernel/asm/mpt/util.asm @@ -10,6 +10,16 @@ // stack: (empty) %endmacro +%macro initialize_rlp_segment + // Write the encoding of the empty node to address 0 leaving 9 bytes for a prefix + // TODO: Do we need a prefix? + PUSH 0x80 + PUSH 0x1000 + %mstore_rlp + PUSH 0x1000 // TODO: use 10? + %mstore_global_metadata(@GLOBAL_METADATA_RLP_DATA_SIZE) +%endmacro + %macro alloc_rlp_block // stack: (empty) %mload_global_metadata(@GLOBAL_METADATA_RLP_DATA_SIZE) diff --git a/evm/src/generation/mod.rs b/evm/src/generation/mod.rs index d691d34e..a3ba3302 100644 --- a/evm/src/generation/mod.rs +++ b/evm/src/generation/mod.rs @@ -296,7 +296,7 @@ pub fn generate_traces, const D: usize>( Ok((tables, public_values)) } -fn simulate_cpu, const D: usize>( +fn _simulate_cpu, const D: usize>( state: &mut GenerationState, ) -> anyhow::Result<()> { let halt_pc = KERNEL.global_labels["halt"]; @@ -333,3 +333,777 @@ fn simulate_cpu, const D: usize>( transition(state)?; } } + +fn __simulate_cpu, const D: usize>( + state: &mut GenerationState, +) -> anyhow::Result<()> { + let mut profiling_map = HashMap::::new(); + + let halt_pc = KERNEL.global_labels["halt"]; + + loop { + // If we've reached the kernel's halt routine, and our trace length is a power of 2, stop. + let pc = state.registers.program_counter; + if let Ok(idx) = KERNEL + .ordered_labels + .binary_search_by_key(&pc, |label| KERNEL.global_labels[label]) + { + profiling_map + .entry(KERNEL.ordered_labels[idx].clone()) + .and_modify(|counter| *counter += 1) + .or_insert(1); + } + let halt = state.registers.is_kernel && pc == halt_pc; + if halt { + log::info!("CPU halted after {} cycles", state.traces.clock()); + + // Padding + let mut row = CpuColumnsView::::default(); + row.clock = F::from_canonical_usize(state.traces.clock()); + row.context = F::from_canonical_usize(state.registers.context); + row.program_counter = F::from_canonical_usize(pc); + row.is_kernel_mode = F::ONE; + row.gas = F::from_canonical_u64(state.registers.gas_used); + row.stack_len = F::from_canonical_usize(state.registers.stack_len); + + loop { + state.traces.push_cpu(row); + row.clock += F::ONE; + if state.traces.clock().is_power_of_two() { + break; + } + } + log::info!("CPU trace padded to {} cycles", state.traces.clock()); + + let mut sorted_labels: Vec<_> = profiling_map.iter().collect(); + sorted_labels.sort_unstable_by_key(|item| item.1); + sorted_labels.reverse(); + log::info!("Offsets: {:?}", sorted_labels); + + return Ok(()); + } + + transition(state)?; + } +} + +fn simulate_cpu, const D: usize>( + state: &mut GenerationState, +) -> anyhow::Result<()> { + let mut profiling_map = HashMap::::new(); + + let halt_pc = KERNEL.global_labels["halt"]; + + loop { + // If we've reached the kernel's halt routine, and our trace length is a power of 2, stop. + let pc = state.registers.program_counter; + let idx = match KERNEL + .ordered_labels + .binary_search_by_key(&pc, |label| KERNEL.global_labels[label]) + { + Ok(idx) => Some(idx), + Err(0) => None, + Err(idx) => Some(idx - 1), + }; + if let Some(idx) = idx { + profiling_map + .entry(KERNEL.ordered_labels[idx].clone()) + .and_modify(|counter| *counter += 1) + .or_insert(1); + } + let halt = state.registers.is_kernel && pc == halt_pc; + if halt { + log::info!("CPU halted after {} cycles", state.traces.clock()); + + // Padding + let mut row = CpuColumnsView::::default(); + row.clock = F::from_canonical_usize(state.traces.clock()); + row.context = F::from_canonical_usize(state.registers.context); + row.program_counter = F::from_canonical_usize(pc); + row.is_kernel_mode = F::ONE; + row.gas = F::from_canonical_u64(state.registers.gas_used); + row.stack_len = F::from_canonical_usize(state.registers.stack_len); + + loop { + state.traces.push_cpu(row); + row.clock += F::ONE; + if state.traces.clock().is_power_of_two() { + break; + } + } + log::info!("CPU trace padded to {} cycles", state.traces.clock()); + + let mut sorted_labels: Vec<_> = profiling_map.iter().collect(); + sorted_labels.sort_unstable_by_key(|item| item.1); + sorted_labels.reverse(); + log::info!("Offsets: {:?}", sorted_labels); + + return Ok(()); + } + + transition(state)?; + { + let _ = [ + ("secp_add_valid_points_no_edge_case", 10980), + ("ecrecover", 9009), + ("num_bytes", 7306), + ("hex_prefix_rlp", 5820), + ("secp_double", 4076), + ("encode_node_branch", 3408), + ("mstore_unpacking", 2368), + ("main", 2320), + ("secp_add_valid_points", 2281), + ("insert_accessed_addresses", 2238), + ("decode_int_given_len", 1809), + ("read_rlp_to_memory", 1626), + ("load_mpt", 1355), + ("encode_or_hash_node", 1160), + ("mpt_read_branch", 1152), + ("mpt_read", 1065), + ("encode_node", 803), + ("memcpy_bytes", 731), + ("encode_account", 662), + ("prepend_rlp_list_prefix", 602), + ("pack_small_rlp", 590), + ("secp_precompute_table", 477), + ("encode_node_leaf", 459), + ("mstore_unpacking_rlp", 448), + ("maybe_hash_node", 438), + ("encode_node_empty", 413), + ("encode_rlp_fixed", 380), + ("insert_touched_addresses", 368), + ("mpt_read_extension_not_found", 340), + ("mpt_read_state_trie", 323), + ("sys_sstore", 313), + ("debug_it_should_be_128", 295), + ("process_receipt", 292), + ("process_type_0_txn", 283), + ("encode_rlp_scalar", 271), + ("check_bloom_loop", 269), + ("mpt_insert_hash_node", 252), + ("initialize_block_bloom", 247), + ("encode_rlp_list_prefix", 221), + ("encode_rlp_multi_byte_string_prefix", 216), + ("mpt_load_state_trie_value", 213), + ("mload_packing", 204), + ("mpt_hash", 198), + ("decode_rlp_string_len", 197), + ("jumpdest_analysis", 164), + ("load_code", 155), + ("process_normalized_txn", 154), + ("secp_glv_decompose", 148), + ("process_message_txn_code_loaded", 145), + ("insert_accessed_storage_keys", 135), + ("delete_all_touched_addresses", 128), + ("mpt_read_leaf_not_found", 119), + ("encode_receipt", 113), + ("increment_nonce", 108), + ("add_eth", 93), + ("process_message_txn", 82), + ("process_message_txn_after_call", 77), + ("doubly_encode_rlp_scalar", 74), + ("deduct_eth", 72), + ("intrinsic_gas", 64), + ("hash_final_tries", 58), + ("update_txn_trie", 58), + ("terminate_common", 53), + ("extcodehash", 45), + ("warm_precompiles", 45), + ("sys_stop", 42), + ("start_txn", 41), + ("mpt_insert", 39), + ("load_all_mpts", 38), + ("sload_current", 36), + ("encode_txn", 36), + ("scalar_to_rlp", 35), + ("encode_rlp_string", 34), + ("hash_initial_tries", 33), + ("encode_node_branch_prepend_prefix", 32), + ("decode_rlp_scalar", 28), + ("encode_rlp_string_small", 24), + ("route_txn", 24), + ("mpt_hash_storage_trie", 24), + ("encode_rlp_string_large", 23), + ("buy_gas", 20), + ("mpt_insert_receipt_trie", 17), + ("transfer_eth", 17), + ("decode_rlp_list_len", 17), + ("mpt_insert_txn_trie", 16), + ("balance", 15), + ("mpt_hash_txn_trie", 14), + ("mpt_hash_receipt_trie", 14), + ("mpt_hash_state_trie", 14), + ("logs_bloom", 13), + ("delete_all_selfdestructed_addresses", 13), + ("encode_rlp_string_large_after_writing_len", 13), + ("txn_after", 12), + ("encode_rlp_256", 12), + ("encode_storage_value", 12), + ("increment_bounded_rlp", 11), + ("withdrawals", 10), + ("warm_coinbase", 9), + ("nonce", 9), + ("increment_sender_nonce", 9), + ("process_based_on_type", 8), + ("after_storage_read", 7), + ("mpt_read_empty", 7), + ("ec_double_retself", 6), + ("warm_origin", 5), + ("add_bignum", 5), + ("check_bloom_loop_end", 4), + ("execute_withdrawals", 3), + ("encode_rlp_160", 3), + ("charge_gas_hook", 2), + ("halt", 1), + ("jumped_to_0", 1), + ]; + let _ = [ + ("secp_add_valid_points_no_edge_case", 10980), + ("ecrecover", 9009), + ("num_bytes", 7306), + ("hex_prefix_rlp", 5820), + ("secp_double", 4076), + ("encode_node_branch", 3408), + ("mstore_unpacking", 2368), + ("main", 2306), + ("secp_add_valid_points", 2281), + ("insert_accessed_addresses", 2238), + ("decode_int_given_len", 1809), + ("encode_node_empty", 1652), + ("read_rlp_to_memory", 1626), + ("load_mpt", 1355), + ("encode_or_hash_node", 1160), + ("mpt_read_branch", 1152), + ("mpt_read", 1065), + ("encode_node", 803), + ("memcpy_bytes", 731), + ("encode_account", 662), + ("prepend_rlp_list_prefix", 602), + ("pack_small_rlp", 590), + ("secp_precompute_table", 477), + ("encode_node_leaf", 459), + ("mstore_unpacking_rlp", 448), + ("maybe_hash_node", 438), + ("encode_rlp_fixed", 380), + ("insert_touched_addresses", 368), + ("mpt_read_extension_not_found", 340), + ("mpt_read_state_trie", 323), + ("sys_sstore", 313), + ("hash_final_tries", 305), + ("process_receipt", 292), + ("process_type_0_txn", 283), + ("encode_rlp_scalar", 271), + ("check_bloom_loop", 269), + ("mpt_insert_hash_node", 252), + ("encode_rlp_list_prefix", 221), + ("encode_rlp_multi_byte_string_prefix", 216), + ("mpt_load_state_trie_value", 213), + ("mload_packing", 204), + ("mpt_hash", 198), + ("decode_rlp_string_len", 197), + ("jumpdest_analysis", 164), + ("load_code", 155), + ("process_normalized_txn", 154), + ("secp_glv_decompose", 148), + ("process_message_txn_code_loaded", 145), + ("insert_accessed_storage_keys", 135), + ("delete_all_touched_addresses", 128), + ("mpt_read_leaf_not_found", 119), + ("encode_receipt", 113), + ("increment_nonce", 108), + ("add_eth", 93), + ("process_message_txn", 82), + ("process_message_txn_after_call", 77), + ("doubly_encode_rlp_scalar", 74), + ("deduct_eth", 72), + ("intrinsic_gas", 64), + ("update_txn_trie", 58), + ("terminate_common", 53), + ("warm_precompiles", 45), + ("extcodehash", 45), + ("sys_stop", 42), + ("start_txn", 41), + ("mpt_insert", 39), + ("load_all_mpts", 38), + ("sload_current", 36), + ("encode_txn", 36), + ("scalar_to_rlp", 35), + ("encode_rlp_string", 34), + ("hash_initial_tries", 33), + ("encode_node_branch_prepend_prefix", 32), + ("decode_rlp_scalar", 28), + ("route_txn", 24), + ("mpt_hash_storage_trie", 24), + ("encode_rlp_string_small", 24), + ("encode_rlp_string_large", 23), + ("buy_gas", 20), + ("decode_rlp_list_len", 17), + ("transfer_eth", 17), + ("mpt_insert_receipt_trie", 17), + ("mpt_insert_txn_trie", 16), + ("balance", 15), + ("mpt_hash_receipt_trie", 14), + ("mpt_hash_txn_trie", 14), + ("mpt_hash_state_trie", 14), + ("delete_all_selfdestructed_addresses", 13), + ("logs_bloom", 13), + ("encode_rlp_string_large_after_writing_len", 13), + ("encode_storage_value", 12), + ("encode_rlp_256", 12), + ("txn_after", 12), + ("increment_bounded_rlp", 11), + ("withdrawals", 10), + ("nonce", 9), + ("increment_sender_nonce", 9), + ("warm_coinbase", 9), + ("process_based_on_type", 8), + ("after_storage_read", 7), + ("mpt_read_empty", 7), + ("ec_double_retself", 6), + ("add_bignum", 5), + ("warm_origin", 5), + ("check_bloom_loop_end", 4), + ("encode_rlp_160", 3), + ("execute_withdrawals", 3), + ("charge_gas_hook", 2), + ("halt", 1), + ("jumped_to_0", 1), + ]; + + let _ = [ + ("mstore_unpacking", 148), + ("secp_add_valid_points", 139), + ("secp_add_valid_points_no_edge_case", 132), + ("secp_double", 129), + ("mstore_unpacking_rlp", 112), + ("encode_or_hash_node", 76), + ("encode_node", 72), + ("maybe_hash_node", 72), + ("mload_packing", 68), + ("pack_small_rlp", 59), + ("encode_node_empty", 59), + ("mpt_read", 50), + ("num_bytes", 48), + ("load_mpt", 38), + ("mpt_read_branch", 32), + ("memcpy_bytes", 27), + ("encode_rlp_fixed", 20), + ("encode_rlp_scalar", 19), + ("mpt_read_state_trie", 17), + ("prepend_rlp_list_prefix", 14), + ("encode_rlp_256", 12), + ("mpt_hash", 12), + ("insert_accessed_addresses", 12), + ("decode_rlp_string_len", 9), + ("hex_prefix_rlp", 9), + ("encode_node_leaf", 9), + ("decode_int_given_len", 9), + ("encode_rlp_multi_byte_string_prefix", 8), + ("encode_rlp_list_prefix", 8), + ("decode_rlp_scalar", 7), + ("mpt_hash_storage_trie", 6), + ("encode_account", 6), + ("insert_touched_addresses", 5), + ("encode_node_branch_prepend_prefix", 4), + ("encode_node_branch", 4), + ("mpt_load_state_trie_value", 3), + ("extcodehash", 3), + ("mpt_insert", 3), + ("add_eth", 3), + ("mpt_hash_state_trie", 2), + ("encode_rlp_string", 2), + ("deduct_eth", 2), + ("mpt_hash_txn_trie", 2), + ("ec_double_retself", 2), + ("mpt_hash_receipt_trie", 2), + ("secp_glv_decompose", 2), + ("charge_gas_hook", 2), + ("sys_sstore", 1), + ("increment_sender_nonce", 1), + ("buy_gas", 1), + ("main", 1), + ("process_type_0_txn", 1), + ("jumpdest_analysis", 1), + ("txn_after", 1), + ("encode_rlp_160", 1), + ("intrinsic_gas", 1), + ("delete_all_selfdestructed_addresses", 1), + ("encode_rlp_string_large_after_writing_len", 1), + ("jumped_to_0", 1), + ("decode_rlp_list_len", 1), + ("mpt_read_empty", 1), + ("hash_final_tries", 1), + ("sload_current", 1), + ("encode_txn", 1), + ("start_txn", 1), + ("encode_rlp_string_large", 1), + ("load_code", 1), + ("increment_bounded_rlp", 1), + ("encode_receipt", 1), + ("process_message_txn", 1), + ("ecrecover", 1), + ("warm_origin", 1), + ("encode_rlp_string_small", 1), + ("process_based_on_type", 1), + ("secp_precompute_table", 1), + ("halt", 1), + ("update_txn_trie", 1), + ("transfer_eth", 1), + ("logs_bloom", 1), + ("read_rlp_to_memory", 1), + ("encode_storage_value", 1), + ("process_receipt", 1), + ("process_message_txn_code_loaded", 1), + ("increment_nonce", 1), + ("delete_all_touched_addresses", 1), + ("terminate_common", 1), + ("balance", 1), + ("withdrawals", 1), + ("sys_stop", 1), + ("after_storage_read", 1), + ("mpt_insert_receipt_trie", 1), + ("hash_initial_tries", 1), + ("doubly_encode_rlp_scalar", 1), + ("route_txn", 1), + ("mpt_insert_txn_trie", 1), + ("warm_coinbase", 1), + ("load_all_mpts", 1), + ("warm_precompiles", 1), + ("add_bignum", 1), + ("insert_accessed_storage_keys", 1), + ("process_normalized_txn", 1), + ("scalar_to_rlp", 1), + ("nonce", 1), + ("process_message_txn_after_call", 1), + ("execute_withdrawals", 1), + ]; + let _ = [ + ("secp_add_valid_points_no_edge_case", 10980), + ("ecrecover", 9009), + ("num_bytes", 7306), + ("hex_prefix_rlp", 5820), + ("secp_double", 4076), + ("encode_node_branch", 3440), + ("encode_or_hash_node", 2991), + ("mstore_unpacking", 2368), + ("main", 2306), + ("secp_add_valid_points", 2281), + ("insert_accessed_addresses", 2238), + ("decode_int_given_len", 1809), + ("encode_node_empty", 1652), + ("read_rlp_to_memory", 1626), + ("load_mpt", 1355), + ("mpt_read_branch", 1152), + ("mpt_read", 1065), + ("memcpy_bytes", 731), + ("encode_account", 662), + ("prepend_rlp_list_prefix", 602), + ("hash_final_tries", 578), + ("secp_precompute_table", 477), + ("encode_node_leaf", 459), + ("mstore_unpacking_rlp", 448), + ("encode_rlp_fixed", 380), + ("insert_touched_addresses", 368), + ("mpt_read_extension_not_found", 340), + ("mpt_read_state_trie", 323), + ("sys_sstore", 313), + ("process_receipt", 292), + ("process_type_0_txn", 283), + ("encode_rlp_scalar", 271), + ("mpt_insert_hash_node", 252), + ("encode_rlp_list_prefix", 221), + ("encode_rlp_multi_byte_string_prefix", 216), + ("mpt_load_state_trie_value", 213), + ("mload_packing", 204), + ("mpt_hash", 198), + ("decode_rlp_string_len", 197), + ("jumpdest_analysis", 164), + ("load_code", 155), + ("process_normalized_txn", 154), + ("secp_glv_decompose", 148), + ("process_message_txn_code_loaded", 145), + ("insert_accessed_storage_keys", 135), + ("delete_all_touched_addresses", 128), + ("mpt_read_leaf_not_found", 119), + ("encode_receipt", 113), + ("increment_nonce", 108), + ("add_eth", 93), + ("process_message_txn", 82), + ("process_message_txn_after_call", 77), + ("doubly_encode_rlp_scalar", 74), + ("deduct_eth", 72), + ("intrinsic_gas", 64), + ("update_txn_trie", 58), + ("terminate_common", 53), + ("warm_precompiles", 45), + ("extcodehash", 45), + ("sys_stop", 42), + ("start_txn", 41), + ("mpt_insert", 39), + ("load_all_mpts", 38), + ("encode_txn", 36), + ("sload_current", 36), + ("scalar_to_rlp", 35), + ("encode_rlp_string", 34), + ("hash_initial_tries", 33), + ("decode_rlp_scalar", 28), + ("route_txn", 24), + ("mpt_hash_storage_trie", 24), + ("encode_rlp_string_small", 24), + ("encode_rlp_string_large", 23), + ("buy_gas", 20), + ("transfer_eth", 17), + ("mpt_insert_receipt_trie", 17), + ("decode_rlp_list_len", 17), + ("mpt_insert_txn_trie", 16), + ("balance", 15), + ("mpt_hash_txn_trie", 14), + ("mpt_hash_receipt_trie", 14), + ("mpt_hash_state_trie", 14), + ("delete_all_selfdestructed_addresses", 13), + ("logs_bloom", 13), + ("encode_rlp_string_large_after_writing_len", 13), + ("encode_storage_value", 12), + ("encode_rlp_256", 12), + ("txn_after", 12), + ("increment_bounded_rlp", 11), + ("withdrawals", 10), + ("increment_sender_nonce", 9), + ("warm_coinbase", 9), + ("nonce", 9), + ("process_based_on_type", 8), + ("after_storage_read", 7), + ("mpt_read_empty", 7), + ("ec_double_retself", 6), + ("add_bignum", 5), + ("warm_origin", 5), + ("encode_rlp_160", 3), + ("execute_withdrawals", 3), + ("charge_gas_hook", 2), + ("jumped_to_0", 1), + ("halt", 1), + ]; + + let _ = [ + ("secp_add_valid_points_no_edge_case", 10980), + ("ecrecover", 9009), + ("num_bytes", 7306), + ("hex_prefix_rlp", 5820), + ("secp_double", 4076), + ("encode_node_branch", 3440), + ("mstore_unpacking", 2368), + ("main", 2306), + ("secp_add_valid_points", 2281), + ("insert_accessed_addresses", 2238), + ("decode_int_given_len", 1809), + ("encode_node_empty", 1652), + ("read_rlp_to_memory", 1626), + ("load_mpt", 1355), + ("encode_or_hash_node", 1160), + ("mpt_read_branch", 1152), + ("mpt_read", 1065), + ("encode_node", 803), + ("memcpy_bytes", 731), + ("encode_account", 662), + ("prepend_rlp_list_prefix", 602), + ("pack_small_rlp", 590), + ("hash_final_tries", 578), + ("secp_precompute_table", 477), + ("encode_node_leaf", 459), + ("mstore_unpacking_rlp", 448), + ("maybe_hash_node", 438), + ("encode_rlp_fixed", 380), + ("insert_touched_addresses", 368), + ("mpt_read_extension_not_found", 340), + ("mpt_read_state_trie", 323), + ("sys_sstore", 313), + ("process_receipt", 292), + ("process_type_0_txn", 283), + ("encode_rlp_scalar", 271), + ("mpt_insert_hash_node", 252), + ("encode_rlp_list_prefix", 221), + ("encode_rlp_multi_byte_string_prefix", 216), + ("mpt_load_state_trie_value", 213), + ("mload_packing", 204), + ("mpt_hash", 198), + ("decode_rlp_string_len", 197), + ("jumpdest_analysis", 164), + ("load_code", 155), + ("process_normalized_txn", 154), + ("secp_glv_decompose", 148), + ("process_message_txn_code_loaded", 145), + ("insert_accessed_storage_keys", 135), + ("delete_all_touched_addresses", 128), + ("mpt_read_leaf_not_found", 119), + ("encode_receipt", 113), + ("increment_nonce", 108), + ("add_eth", 93), + ("process_message_txn", 82), + ("process_message_txn_after_call", 77), + ("doubly_encode_rlp_scalar", 74), + ("deduct_eth", 72), + ("intrinsic_gas", 64), + ("update_txn_trie", 58), + ("terminate_common", 53), + ("extcodehash", 45), + ("warm_precompiles", 45), + ("sys_stop", 42), + ("start_txn", 41), + ("mpt_insert", 39), + ("load_all_mpts", 38), + ("encode_txn", 36), + ("sload_current", 36), + ("scalar_to_rlp", 35), + ("encode_rlp_string", 34), + ("hash_initial_tries", 33), + ("decode_rlp_scalar", 28), + ("route_txn", 24), + ("mpt_hash_storage_trie", 24), + ("encode_rlp_string_small", 24), + ("encode_rlp_string_large", 23), + ("buy_gas", 20), + ("decode_rlp_list_len", 17), + ("transfer_eth", 17), + ("mpt_insert_receipt_trie", 17), + ("mpt_insert_txn_trie", 16), + ("balance", 15), + ("mpt_hash_txn_trie", 14), + ("mpt_hash_receipt_trie", 14), + ("mpt_hash_state_trie", 14), + ("encode_rlp_string_large_after_writing_len", 13), + ("logs_bloom", 13), + ("delete_all_selfdestructed_addresses", 13), + ("txn_after", 12), + ("encode_storage_value", 12), + ("encode_rlp_256", 12), + ("increment_bounded_rlp", 11), + ("withdrawals", 10), + ("nonce", 9), + ("increment_sender_nonce", 9), + ("warm_coinbase", 9), + ("process_based_on_type", 8), + ("mpt_read_empty", 7), + ("after_storage_read", 7), + ("ec_double_retself", 6), + ("add_bignum", 5), + ("warm_origin", 5), + ("encode_rlp_160", 3), + ("execute_withdrawals", 3), + ("charge_gas_hook", 2), + ("halt", 1), + ("jumped_to_0", 1), + ]; + + let _ = [ + ("secp_add_valid_points_no_edge_case", 10980), + ("ecrecover", 9009), + ("num_bytes", 7306), + ("hex_prefix_rlp", 5820), + ("secp_double", 4076), + ("encode_node_branch", 3408), + ("mstore_unpacking", 2368), + ("main", 2306), + ("secp_add_valid_points", 2281), + ("insert_accessed_addresses", 2238), + ("decode_int_given_len", 1809), + ("encode_node_empty", 1652), + ("read_rlp_to_memory", 1626), + ("load_mpt", 1355), + ("encode_or_hash_node", 1160), + ("mpt_read_branch", 1152), + ("mpt_read", 1065), + ("encode_node", 803), + ("memcpy_bytes", 731), + ("encode_account", 662), + ("prepend_rlp_list_prefix", 602), + ("pack_small_rlp", 590), + ("hash_final_tries", 578), + ("secp_precompute_table", 477), + ("encode_node_leaf", 459), + ("mstore_unpacking_rlp", 448), + ("maybe_hash_node", 438), + ("encode_rlp_fixed", 380), + ("insert_touched_addresses", 368), + ("mpt_read_extension_not_found", 340), + ("mpt_read_state_trie", 323), + ("sys_sstore", 313), + ("process_receipt", 292), + ("process_type_0_txn", 283), + ("encode_rlp_scalar", 271), + ("mpt_insert_hash_node", 252), + ("encode_rlp_list_prefix", 221), + ("encode_rlp_multi_byte_string_prefix", 216), + ("mpt_load_state_trie_value", 213), + ("mload_packing", 204), + ("mpt_hash", 198), + ("decode_rlp_string_len", 197), + ("jumpdest_analysis", 164), + ("load_code", 155), + ("process_normalized_txn", 154), + ("secp_glv_decompose", 148), + ("process_message_txn_code_loaded", 145), + ("insert_accessed_storage_keys", 135), + ("delete_all_touched_addresses", 128), + ("mpt_read_leaf_not_found", 119), + ("encode_receipt", 113), + ("increment_nonce", 108), + ("add_eth", 93), + ("process_message_txn", 82), + ("process_message_txn_after_call", 77), + ("doubly_encode_rlp_scalar", 74), + ("deduct_eth", 72), + ("intrinsic_gas", 64), + ("update_txn_trie", 58), + ("terminate_common", 53), + ("extcodehash", 45), + ("warm_precompiles", 45), + ("sys_stop", 42), + ("start_txn", 41), + ("mpt_insert", 39), + ("load_all_mpts", 38), + ("encode_txn", 36), + ("sload_current", 36), + ("scalar_to_rlp", 35), + ("encode_rlp_string", 34), + ("hash_initial_tries", 33), + ("encode_node_branch_prepend_prefix", 32), + ("decode_rlp_scalar", 28), + ("mpt_hash_storage_trie", 24), + ("route_txn", 24), + ("encode_rlp_string_small", 24), + ("encode_rlp_string_large", 23), + ("buy_gas", 20), + ("transfer_eth", 17), + ("mpt_insert_receipt_trie", 17), + ("decode_rlp_list_len", 17), + ("mpt_insert_txn_trie", 16), + ("balance", 15), + ("mpt_hash_txn_trie", 14), + ("mpt_hash_state_trie", 14), + ("mpt_hash_receipt_trie", 14), + ("delete_all_selfdestructed_addresses", 13), + ("logs_bloom", 13), + ("encode_rlp_string_large_after_writing_len", 13), + ("txn_after", 12), + ("encode_rlp_256", 12), + ("encode_storage_value", 12), + ("increment_bounded_rlp", 11), + ("withdrawals", 10), + ("warm_coinbase", 9), + ("increment_sender_nonce", 9), + ("nonce", 9), + ("process_based_on_type", 8), + ("mpt_read_empty", 7), + ("after_storage_read", 7), + ("ec_double_retself", 6), + ("add_bignum", 5), + ("warm_origin", 5), + ("encode_rlp_160", 3), + ("execute_withdrawals", 3), + ("charge_gas_hook", 2), + ("halt", 1), + ("jumped_to_0", 1), + ]; + } + } +}