Address bundling

evm/src/cpu/byte_unpacking.rs

@@ -16,17 +16,30 @@ pub(crate) fn eval_packed<P: PackedField>(
     // The MSTORE_32BYTES opcodes are differentiated from MLOAD_32BYTES
     // by the 5th bit set to 0.
     let filter = lv.op.m_op_32bytes * (lv.opcode_bits[5] - P::ONES);
-    let new_offset = nv.mem_channels[0].value;
-    let virt = lv.mem_channels[2].value[0];
+
+    // The address to write to is stored in the first memory channel.
+    // It contains virt, segment, ctx in its first 3 limbs, and 0 otherwise.
+    // The new address is identical, except for its `virtual` limb that is increased by the corresponding `len` offset.
+    let new_addr = nv.mem_channels[0].value;
+    let written_addr = lv.mem_channels[0].value;
+
     // Read len from opcode bits and constrain the pushed new offset.
     let len_bits: P = lv.opcode_bits[..5]
         .iter()
         .enumerate()
         .map(|(i, &bit)| bit * P::Scalar::from_canonical_u64(1 << i))
         .sum();
     let len = len_bits + P::ONES;
-    yield_constr.constraint(filter * (new_offset[0] - virt - len));
-    for &limb in &new_offset[1..] {
+
+    // Check that `virt` is increased properly.
+    yield_constr.constraint(filter * (new_addr[0] - written_addr[0] - len));
+
+    // Check that `segment` and `ctx` do not change.
+    yield_constr.constraint(filter * (new_addr[1] - written_addr[1]));
+    yield_constr.constraint(filter * (new_addr[2] - written_addr[2]));
+
+    // Check that the rest of the returned address is null.
+    for &limb in &new_addr[3..] {
         yield_constr.constraint(filter * limb);
     }
 }
@@ -41,20 +54,40 @@ pub(crate) fn eval_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
     // by the 5th bit set to 0.
     let filter =
         builder.mul_sub_extension(lv.op.m_op_32bytes, lv.opcode_bits[5], lv.op.m_op_32bytes);
-    let new_offset = nv.mem_channels[0].value;
-    let virt = lv.mem_channels[2].value[0];
+
+    // The address to write to is stored in the first memory channel.
+    // It contains virt, segment, ctx in its first 3 limbs, and 0 otherwise.
+    // The new address is identical, except for its `virtual` limb that is increased by the corresponding `len` offset.
+    let new_addr = nv.mem_channels[0].value;
+    let written_addr = lv.mem_channels[0].value;
+
     // Read len from opcode bits and constrain the pushed new offset.
     let len_bits = lv.opcode_bits[..5].iter().enumerate().fold(
         builder.zero_extension(),
         |cumul, (i, &bit)| {
             builder.mul_const_add_extension(F::from_canonical_u64(1 << i), bit, cumul)
         },
     );
-    let diff = builder.sub_extension(new_offset[0], virt);
+
+    // Check that `virt` is increased properly.
+    let diff = builder.sub_extension(new_addr[0], written_addr[0]);
     let diff = builder.sub_extension(diff, len_bits);
     let constr = builder.mul_sub_extension(filter, diff, filter);
     yield_constr.constraint(builder, constr);
-    for &limb in &new_offset[1..] {
+
+    // Check that `segment` and `ctx` do not change.
+    {
+        let diff = builder.sub_extension(new_addr[1], written_addr[1]);
+        let constr = builder.mul_extension(filter, diff);
+        yield_constr.constraint(builder, constr);
+
+        let diff = builder.sub_extension(new_addr[2], written_addr[2]);
+        let constr = builder.mul_extension(filter, diff);
+        yield_constr.constraint(builder, constr);
+    }
+
+    // Check that the rest of the returned address is null.
+    for &limb in &new_addr[3..] {
         let constr = builder.mul_extension(filter, limb);
         yield_constr.constraint(builder, constr);
     }

evm/src/cpu/contextops.rs

@@ -11,7 +11,8 @@ use super::membus::NUM_GP_CHANNELS;
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 use crate::cpu::columns::CpuColumnsView;
 use crate::cpu::kernel::constants::context_metadata::ContextMetadata;
-use crate::memory::segments::Segment;
+use crate::memory::segments::{Segment, SEGMENT_SCALING_FACTOR};
+use crate::memory::VALUE_LIMBS;
 
 // If true, the instruction will keep the current context for the next row.
 // If false, next row's context is handled manually.
@@ -83,9 +84,13 @@ fn eval_packed_get<P: PackedField>(
     // If the opcode is GET_CONTEXT, then lv.opcode_bits[0] = 0.
     let filter = lv.op.context_op * (P::ONES - lv.opcode_bits[0]);
     let new_stack_top = nv.mem_channels[0].value;
-    yield_constr.constraint(filter * (new_stack_top[0] - lv.context));
-    for &limb in &new_stack_top[1..] {
-        yield_constr.constraint(filter * limb);
+    // Context is scaled by 2^64, hence stored in the 3rd limb.
+    yield_constr.constraint(filter * (new_stack_top[2] - lv.context));
+
+    for (i, &limb) in new_stack_top.iter().enumerate() {
+        if i != 2 {
+            yield_constr.constraint(filter * limb);
+        }
     }
 
     // Constrain new stack length.
@@ -113,14 +118,18 @@ fn eval_ext_circuit_get<F: RichField + Extendable<D>, const D: usize>(
     let prod = builder.mul_extension(lv.op.context_op, lv.opcode_bits[0]);
     let filter = builder.sub_extension(lv.op.context_op, prod);
     let new_stack_top = nv.mem_channels[0].value;
+    // Context is scaled by 2^64, hence stored in the 3rd limb.
     {
-        let diff = builder.sub_extension(new_stack_top[0], lv.context);
+        let diff = builder.sub_extension(new_stack_top[2], lv.context);
         let constr = builder.mul_extension(filter, diff);
         yield_constr.constraint(builder, constr);
     }
-    for &limb in &new_stack_top[1..] {
-        let constr = builder.mul_extension(filter, limb);
-        yield_constr.constraint(builder, constr);
+
+    for (i, &limb) in new_stack_top.iter().enumerate() {
+        if i != 2 {
+            let constr = builder.mul_extension(filter, limb);
+            yield_constr.constraint(builder, constr);
+        }
     }
 
     // Constrain new stack length.
@@ -155,13 +164,20 @@ fn eval_packed_set<P: PackedField>(
     let stack_top = lv.mem_channels[0].value;
     let write_old_sp_channel = lv.mem_channels[1];
     let read_new_sp_channel = lv.mem_channels[2];
-    let ctx_metadata_segment = P::Scalar::from_canonical_u64(Segment::ContextMetadata as u64);
-    let stack_size_field = P::Scalar::from_canonical_u64(ContextMetadata::StackSize as u64);
+    let ctx_metadata_segment =
+        P::Scalar::from_canonical_u64(Segment::ContextMetadata as u64 >> SEGMENT_SCALING_FACTOR);
+    let stack_size_field = P::Scalar::from_canonical_u64(
+        // We need to unscale the context metadata.
+        ContextMetadata::StackSize as u64 - Segment::ContextMetadata as u64,
+    );
     let local_sp_dec = lv.stack_len - P::ONES;
 
     // The next row's context is read from stack_top.
-    yield_constr.constraint(filter * (stack_top[0] - nv.context));
-    for &limb in &stack_top[1..] {
+    yield_constr.constraint(filter * (stack_top[2] - nv.context));
+    for &limb in &stack_top[0..2] {
+        yield_constr.constraint(filter * limb);
+    }
+    for &limb in &stack_top[3..] {
         yield_constr.constraint(filter * limb);
     }
 
@@ -220,22 +236,27 @@ fn eval_ext_circuit_set<F: RichField + Extendable<D>, const D: usize>(
     let stack_top = lv.mem_channels[0].value;
     let write_old_sp_channel = lv.mem_channels[1];
     let read_new_sp_channel = lv.mem_channels[2];
-    let ctx_metadata_segment = builder.constant_extension(F::Extension::from_canonical_u32(
-        Segment::ContextMetadata as u32,
+    let ctx_metadata_segment = builder.constant_extension(F::Extension::from_canonical_u64(
+        Segment::ContextMetadata as u64 >> SEGMENT_SCALING_FACTOR,
     ));
-    let stack_size_field = builder.constant_extension(F::Extension::from_canonical_u32(
-        ContextMetadata::StackSize as u32,
+    let stack_size_field = builder.constant_extension(F::Extension::from_canonical_u64(
+        // We need to unscale the context metadata.
+        ContextMetadata::StackSize as u64 - Segment::ContextMetadata as u64,
     ));
     let one = builder.one_extension();
     let local_sp_dec = builder.sub_extension(lv.stack_len, one);
 
     // The next row's context is read from stack_top.
     {
-        let diff = builder.sub_extension(stack_top[0], nv.context);
+        let diff = builder.sub_extension(stack_top[2], nv.context);
         let constr = builder.mul_extension(filter, diff);
         yield_constr.constraint(builder, constr);
     }
-    for &limb in &stack_top[1..] {
+    for &limb in &stack_top[0..2] {
+        let constr = builder.mul_extension(filter, limb);
+        yield_constr.constraint(builder, constr);
+    }
+    for &limb in &stack_top[3..] {
         let constr = builder.mul_extension(filter, limb);
         yield_constr.constraint(builder, constr);
     }
@@ -368,7 +389,9 @@ pub(crate) fn eval_packed<P: PackedField>(
     yield_constr.constraint(new_filter * (channel.addr_context - nv.context));
     // Same segment for both.
     yield_constr.constraint(
-        new_filter * (channel.addr_segment - P::Scalar::from_canonical_u64(Segment::Stack as u64)),
+        new_filter
+            * (channel.addr_segment
+                - P::Scalar::from_canonical_u64(Segment::Stack as u64 >> SEGMENT_SCALING_FACTOR)),
     );
     // The address is one less than stack_len.
     let addr_virtual = stack_len - P::ONES;
@@ -429,7 +452,7 @@ pub(crate) fn eval_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
     {
         let diff = builder.add_const_extension(
             channel.addr_segment,
-            -F::from_canonical_u64(Segment::Stack as u64),
+            -F::from_canonical_u64(Segment::Stack as u64 >> SEGMENT_SCALING_FACTOR),
         );
         let constr = builder.mul_extension(new_filter, diff);
         yield_constr.constraint(builder, constr);

evm/src/cpu/cpu_stark.rs

@@ -21,23 +21,21 @@ use crate::cpu::{
 };
 use crate::cross_table_lookup::{Column, Filter, TableWithColumns};
 use crate::evaluation_frame::{StarkEvaluationFrame, StarkFrame};
-use crate::memory::segments::Segment;
+use crate::memory::segments::{Segment, SEGMENT_SCALING_FACTOR};
 use crate::memory::{NUM_CHANNELS, VALUE_LIMBS};
 use crate::stark::Stark;
 
 /// Creates the vector of `Columns` corresponding to the General Purpose channels when calling the Keccak sponge:
 /// the CPU reads the output of the sponge directly from the `KeccakSpongeStark` table.
 pub(crate) fn ctl_data_keccak_sponge<F: Field>() -> Vec<Column<F>> {
     // When executing KECCAK_GENERAL, the GP memory channels are used as follows:
-    // GP channel 0: stack[-1] = context
-    // GP channel 1: stack[-2] = segment
-    // GP channel 2: stack[-3] = virt
-    // GP channel 3: stack[-4] = len
-    // Next GP channel 0: pushed = outputs
-    let context = Column::single(COL_MAP.mem_channels[0].value[0]);
-    let segment = Column::single(COL_MAP.mem_channels[1].value[0]);
-    let virt = Column::single(COL_MAP.mem_channels[2].value[0]);
-    let len = Column::single(COL_MAP.mem_channels[3].value[0]);
+    // GP channel 0: stack[-1] = addr (context, segment, virt)
+    // GP channel 1: stack[-2] = len
+    // GP channel 4: pushed = outputs
+    let context = Column::single(COL_MAP.mem_channels[0].value[2]);
+    let segment = Column::single(COL_MAP.mem_channels[0].value[1]);
+    let virt = Column::single(COL_MAP.mem_channels[0].value[0]);
+    let len = Column::single(COL_MAP.mem_channels[1].value[0]);
 
     let num_channels = F::from_canonical_usize(NUM_CHANNELS);
     let timestamp = Column::linear_combination([(COL_MAP.clock, num_channels)]);
@@ -149,27 +147,30 @@ pub(crate) fn ctl_data_byte_unpacking<F: Field>() -> Vec<Column<F>> {
     let is_read = Column::constant(F::ZERO);
 
     // When executing MSTORE_32BYTES, the GP memory channels are used as follows:
-    // GP channel 0: stack[-1] = context
-    // GP channel 1: stack[-2] = segment
-    // GP channel 2: stack[-3] = virt
-    // GP channel 3: stack[-4] = val
+    // GP channel 0: stack[-1] = addr (context, segment, virt)
+    // GP channel 1: stack[-2] = val
     // Next GP channel 0: pushed = new_offset (virt + len)
-    let context = Column::single(COL_MAP.mem_channels[0].value[0]);
-    let segment = Column::single(COL_MAP.mem_channels[1].value[0]);
-    let virt = Column::single(COL_MAP.mem_channels[2].value[0]);
-    let val = Column::singles(COL_MAP.mem_channels[3].value);
+    let (context, segment, virt) = get_addr(&COL_MAP, 0);
+    let mut res = vec![
+        is_read,
+        Column::single(context),
+        Column::single(segment),
+        Column::single(virt),
+    ];
 
     // len can be reconstructed as new_offset - virt.
     let len = Column::linear_combination_and_next_row_with_constant(
-        [(COL_MAP.mem_channels[2].value[0], -F::ONE)],
+        [(COL_MAP.mem_channels[0].value[0], -F::ONE)],
         [(COL_MAP.mem_channels[0].value[0], F::ONE)],
         F::ZERO,
     );
+    res.push(len);
 
     let num_channels = F::from_canonical_usize(NUM_CHANNELS);
     let timestamp = Column::linear_combination([(COL_MAP.clock, num_channels)]);
+    res.push(timestamp);
 
-    let mut res = vec![is_read, context, segment, virt, len, timestamp];
+    let val = Column::singles(COL_MAP.mem_channels[1].value);
     res.extend(val);
 
     res
@@ -224,6 +225,20 @@ pub(crate) const MEM_CODE_CHANNEL_IDX: usize = 0;
 /// Index of the first general purpose memory channel.
 pub(crate) const MEM_GP_CHANNELS_IDX_START: usize = MEM_CODE_CHANNEL_IDX + 1;
 
+/// Recover the three components of an address, given a CPU row and
+/// a provided memory channel index.
+/// The components are recovered as follows:
+///
+/// - `context`, shifted by 2^64 (i.e. at index 2)
+/// - `segment`, shifted by 2^32 (i.e. at index 1)
+/// - `virtual`, not shifted (i.e. at index 0)
+pub(crate) const fn get_addr<T: Copy>(lv: &CpuColumnsView<T>, mem_channel: usize) -> (T, T, T) {
+    let addr_context = lv.mem_channels[mem_channel].value[2];
+    let addr_segment = lv.mem_channels[mem_channel].value[1];
+    let addr_virtual = lv.mem_channels[mem_channel].value[0];
+    (addr_context, addr_segment, addr_virtual)
+}
+
 /// Make the time/channel column for memory lookups.
 fn mem_time_and_channel<F: Field>(channel: usize) -> Column<F> {
     let scalar = F::from_canonical_usize(NUM_CHANNELS);
@@ -234,10 +249,12 @@ fn mem_time_and_channel<F: Field>(channel: usize) -> Column<F> {
 /// Creates the vector of `Columns` corresponding to the contents of the code channel when reading code values.
 pub(crate) fn ctl_data_code_memory<F: Field>() -> Vec<Column<F>> {
     let mut cols = vec![
-        Column::constant(F::ONE),                                      // is_read
-        Column::single(COL_MAP.code_context),                          // addr_context
-        Column::constant(F::from_canonical_u64(Segment::Code as u64)), // addr_segment
-        Column::single(COL_MAP.program_counter),                       // addr_virtual
+        Column::constant(F::ONE),             // is_read
+        Column::single(COL_MAP.code_context), // addr_context
+        Column::constant(F::from_canonical_u64(
+            Segment::Code as u64 >> SEGMENT_SCALING_FACTOR,
+        )), // addr_segment
+        Column::single(COL_MAP.program_counter), // addr_virtual
     ];
 
     // Low limb of the value matches the opcode bits

evm/src/cpu/dup_swap.rs

@@ -9,7 +9,7 @@ use plonky2::plonk::circuit_builder::CircuitBuilder;
 use super::membus::NUM_GP_CHANNELS;
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 use crate::cpu::columns::{CpuColumnsView, MemoryChannelView};
-use crate::memory::segments::Segment;
+use crate::memory::segments::{Segment, SEGMENT_SCALING_FACTOR};
 
 /// Constrain two channels to have equal values.
 fn channels_equal_packed<P: PackedField>(
@@ -54,7 +54,9 @@ fn constrain_channel_packed<P: PackedField>(
     yield_constr.constraint(filter * (channel.is_read - P::Scalar::from_bool(is_read)));
     yield_constr.constraint(filter * (channel.addr_context - lv.context));
     yield_constr.constraint(
-        filter * (channel.addr_segment - P::Scalar::from_canonical_u64(Segment::Stack as u64)),
+        filter
+            * (channel.addr_segment
+                - P::Scalar::from_canonical_u64(Segment::Stack as u64 >> SEGMENT_SCALING_FACTOR)),
     );
     // Top of the stack is at `addr = lv.stack_len - 1`.
     let addr_virtual = lv.stack_len - P::ONES - offset;
@@ -94,7 +96,7 @@ fn constrain_channel_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
     {
         let constr = builder.arithmetic_extension(
             F::ONE,
-            -F::from_canonical_u64(Segment::Stack as u64),
+            -F::from_canonical_u64(Segment::Stack as u64 >> SEGMENT_SCALING_FACTOR),
             filter,
             channel.addr_segment,
             filter,

evm/src/cpu/jumps.rs

@@ -7,7 +7,7 @@ use plonky2::iop::ext_target::ExtensionTarget;
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 use crate::cpu::columns::CpuColumnsView;
 use crate::cpu::membus::NUM_GP_CHANNELS;
-use crate::memory::segments::Segment;
+use crate::memory::segments::{Segment, SEGMENT_SCALING_FACTOR};
 
 /// Evaluates constraints for EXIT_KERNEL.
 pub(crate) fn eval_packed_exit_kernel<P: PackedField>(
@@ -87,7 +87,9 @@ pub(crate) fn eval_packed_jump_jumpi<P: PackedField>(
     yield_constr.constraint_transition(new_filter * (channel.is_read - P::ONES));
     yield_constr.constraint_transition(new_filter * (channel.addr_context - nv.context));
     yield_constr.constraint_transition(
-        new_filter * (channel.addr_segment - P::Scalar::from_canonical_u64(Segment::Stack as u64)),
+        new_filter
+            * (channel.addr_segment
+                - P::Scalar::from_canonical_u64(Segment::Stack as u64 >> SEGMENT_SCALING_FACTOR)),
     );
     let addr_virtual = nv.stack_len - P::ONES;
     yield_constr.constraint_transition(new_filter * (channel.addr_virtual - addr_virtual));
@@ -134,7 +136,9 @@ pub(crate) fn eval_packed_jump_jumpi<P: PackedField>(
     yield_constr.constraint(
         filter
             * (jumpdest_flag_channel.addr_segment
-                - P::Scalar::from_canonical_u64(Segment::JumpdestBits as u64)),
+                - P::Scalar::from_canonical_u64(
+                    Segment::JumpdestBits as u64 >> SEGMENT_SCALING_FACTOR,
+                )),
     );
     yield_constr.constraint(filter * (jumpdest_flag_channel.addr_virtual - dst[0]));
 
@@ -203,7 +207,7 @@ pub(crate) fn eval_ext_circuit_jump_jumpi<F: RichField + Extendable<D>, const D:
     {
         let constr = builder.arithmetic_extension(
             F::ONE,
-            -F::from_canonical_u64(Segment::Stack as u64),
+            -F::from_canonical_u64(Segment::Stack as u64 >> SEGMENT_SCALING_FACTOR),
             new_filter,
             channel.addr_segment,
             new_filter,
@@ -306,7 +310,7 @@ pub(crate) fn eval_ext_circuit_jump_jumpi<F: RichField + Extendable<D>, const D:
     {
         let constr = builder.arithmetic_extension(
             F::ONE,
-            -F::from_canonical_u64(Segment::JumpdestBits as u64),
+            -F::from_canonical_u64(Segment::JumpdestBits as u64 >> SEGMENT_SCALING_FACTOR),
             filter,
             jumpdest_flag_channel.addr_segment,
             filter,