SIMD-0321: Provide pointer to instruction data in VM r2

feature-set/src/lib.rs

@@ -156,6 +156,8 @@ impl FeatureSet {
             reenable_zk_elgamal_proof_program: self
                 .is_active(&reenable_zk_elgamal_proof_program::id()),
             raise_cpi_nesting_limit_to_8: self.is_active(&raise_cpi_nesting_limit_to_8::id()),
+            provide_instruction_data_offset_in_vm_r2: self
+                .is_active(&provide_instruction_data_offset_in_vm_r2::id()),
         }
     }
 }
@@ -1126,6 +1128,10 @@ pub mod enforce_fixed_fec_set {
     solana_pubkey::declare_id!("fixfecLZYMfkGzwq6NJA11Yw6KYztzXiK9QcL3K78in");
 }
 
+pub mod provide_instruction_data_offset_in_vm_r2 {
+    solana_pubkey::declare_id!("5xXZc66h4UdB6Yq7FzdBxBiRAFMMScMLwHxk2QZDaNZL");
+}
+
 pub static FEATURE_NAMES: LazyLock<AHashMap<Pubkey, &'static str>> = LazyLock::new(|| {
     [
         (secp256k1_program_enabled::id(), "secp256k1 program"),
@@ -2035,6 +2041,10 @@ pub static FEATURE_NAMES: LazyLock<AHashMap<Pubkey, &'static str>> = LazyLock::n
             enforce_fixed_fec_set::id(),
             "SIMD-0317: Enforce 32 data + 32 coding shreds",
         ),
+        (
+            provide_instruction_data_offset_in_vm_r2::id(),
+            "SIMD-0321: Provide instruction data offset in VM r2",
+        ),
         /*************** ADD NEW FEATURES HERE ***************/
     ]
     .iter()

ledger-tool/src/program.rs

@@ -505,6 +505,10 @@ pub fn program(ledger_path: &Path, matches: &ArgMatches<'_>) {
     let interpreted = matches.value_of("mode").unwrap() != "jit";
     with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
 
+    let provide_instruction_data_offset_in_vm_r2 = invoke_context
+        .get_feature_set()
+        .provide_instruction_data_offset_in_vm_r2;
+
     // Adding `DELAY_VISIBILITY_SLOT_OFFSET` to slots to accommodate for delay visibility of the program
     let mut program_cache_for_tx_batch =
         bank.new_program_cache_for_tx_batch_for_slot(bank.slot() + DELAY_VISIBILITY_SLOT_OFFSET);
@@ -527,16 +531,17 @@ pub fn program(ledger_path: &Path, matches: &ArgMatches<'_>) {
         )
         .unwrap();
     invoke_context.push().unwrap();
-    let (_parameter_bytes, regions, account_lengths) = serialize_parameters(
-        &invoke_context
-            .transaction_context
-            .get_current_instruction_context()
-            .unwrap(),
-        false, // stricter_abi_and_runtime_constraints
-        false, // account_data_direct_mapping
-        true,  // for mask_out_rent_epoch_in_vm_serialization
-    )
-    .unwrap();
+    let (_parameter_bytes, regions, account_lengths, instruction_data_offset) =
+        serialize_parameters(
+            &invoke_context
+                .transaction_context
+                .get_current_instruction_context()
+                .unwrap(),
+            false, // stricter_abi_and_runtime_constraints
+            false, // account_data_direct_mapping
+            true,  // for mask_out_rent_epoch_in_vm_serialization
+        )
+        .unwrap();
 
     let program = matches.value_of("PROGRAM").unwrap();
     let verified_executable = load_program(Path::new(program), program_id, &invoke_context);
@@ -554,6 +559,11 @@ pub fn program(ledger_path: &Path, matches: &ArgMatches<'_>) {
         vm.debug_port = Some(matches.value_of("port").unwrap().parse::<u16>().unwrap());
     }
     vm.registers[1] = MM_INPUT_START;
+
+    // SIMD-0321: Provide offset to instruction data in VM register 2.
+    if provide_instruction_data_offset_in_vm_r2 {
+        vm.registers[2] = instruction_data_offset as u64;
+    }
     let (instruction_count, result) = vm.execute_program(&verified_executable, interpreted);
     let duration = Instant::now() - start_time;
     if matches.occurrences_of("trace") > 0 {

program-runtime/src/serialization.rs

@@ -229,6 +229,7 @@ pub fn serialize_parameters(
         AlignedMemory<HOST_ALIGN>,
         Vec<MemoryRegion>,
         Vec<SerializedAccountMetadata>,
+        usize,
     ),
     InstructionError,
 > {
@@ -323,6 +324,7 @@ fn serialize_parameters_unaligned(
         AlignedMemory<HOST_ALIGN>,
         Vec<MemoryRegion>,
         Vec<SerializedAccountMetadata>,
+        usize,
     ),
     InstructionError,
 > {
@@ -395,11 +397,16 @@ fn serialize_parameters_unaligned(
         };
     }
     s.write::<u64>((instruction_data.len() as u64).to_le());
-    s.write_all(instruction_data);
+    let instruction_data_offset = s.write_all(instruction_data);
     s.write_all(program_id.as_ref());
 
     let (mem, regions) = s.finish();
-    Ok((mem, regions, accounts_metadata))
+    Ok((
+        mem,
+        regions,
+        accounts_metadata,
+        instruction_data_offset as usize,
+    ))
 }
 
 fn deserialize_parameters_unaligned<I: IntoIterator<Item = usize>>(
@@ -476,6 +483,7 @@ fn serialize_parameters_aligned(
         AlignedMemory<HOST_ALIGN>,
         Vec<MemoryRegion>,
         Vec<SerializedAccountMetadata>,
+        usize,
     ),
     InstructionError,
 > {
@@ -557,11 +565,16 @@ fn serialize_parameters_aligned(
         };
     }
     s.write::<u64>((instruction_data.len() as u64).to_le());
-    s.write_all(instruction_data);
+    let instruction_data_offset = s.write_all(instruction_data);
     s.write_all(program_id.as_ref());
 
     let (mem, regions) = s.finish();
-    Ok((mem, regions, accounts_metadata))
+    Ok((
+        mem,
+        regions,
+        accounts_metadata,
+        instruction_data_offset as usize,
+    ))
 }
 
 fn deserialize_parameters_aligned<I: IntoIterator<Item = usize>>(
@@ -812,7 +825,8 @@ mod tests {
                     continue;
                 }
 
-                let (mut serialized, regions, _account_lengths) = serialization_result.unwrap();
+                let (mut serialized, regions, _account_lengths, _instruction_data_offset) =
+                    serialization_result.unwrap();
                 let mut serialized_regions = concat_regions(&regions);
                 let (de_program_id, de_accounts, de_instruction_data) = unsafe {
                     deserialize(
@@ -957,13 +971,14 @@ mod tests {
                 .unwrap();
 
             // check serialize_parameters_aligned
-            let (mut serialized, regions, accounts_metadata) = serialize_parameters(
-                &instruction_context,
-                stricter_abi_and_runtime_constraints,
-                false, // account_data_direct_mapping
-                true,  // mask_out_rent_epoch_in_vm_serialization
-            )
-            .unwrap();
+            let (mut serialized, regions, accounts_metadata, _instruction_data_offset) =
+                serialize_parameters(
+                    &instruction_context,
+                    stricter_abi_and_runtime_constraints,
+                    false, // account_data_direct_mapping
+                    true,  // mask_out_rent_epoch_in_vm_serialization
+                )
+                .unwrap();
 
             let mut serialized_regions = concat_regions(&regions);
             if !stricter_abi_and_runtime_constraints {
@@ -1051,13 +1066,14 @@ mod tests {
                 .get_current_instruction_context()
                 .unwrap();
 
-            let (mut serialized, regions, account_lengths) = serialize_parameters(
-                &instruction_context,
-                stricter_abi_and_runtime_constraints,
-                false, // account_data_direct_mapping
-                true,  // mask_out_rent_epoch_in_vm_serialization
-            )
-            .unwrap();
+            let (mut serialized, regions, account_lengths, _instruction_data_offset) =
+                serialize_parameters(
+                    &instruction_context,
+                    stricter_abi_and_runtime_constraints,
+                    false, // account_data_direct_mapping
+                    true,  // mask_out_rent_epoch_in_vm_serialization
+                )
+                .unwrap();
             let mut serialized_regions = concat_regions(&regions);
 
             let (de_program_id, de_accounts, de_instruction_data) = unsafe {
@@ -1218,13 +1234,14 @@ mod tests {
                 .unwrap();
 
             // check serialize_parameters_aligned
-            let (_serialized, regions, _accounts_metadata) = serialize_parameters(
-                &instruction_context,
-                true,
-                false, // account_data_direct_mapping
-                mask_out_rent_epoch_in_vm_serialization,
-            )
-            .unwrap();
+            let (_serialized, regions, _accounts_metadata, _instruction_data_offset) =
+                serialize_parameters(
+                    &instruction_context,
+                    true,
+                    false, // account_data_direct_mapping
+                    mask_out_rent_epoch_in_vm_serialization,
+                )
+                .unwrap();
 
             let mut serialized_regions = concat_regions(&regions);
             let (_de_program_id, de_accounts, _de_instruction_data) = unsafe {
@@ -1250,13 +1267,14 @@ mod tests {
                 .get_current_instruction_context()
                 .unwrap();
 
-            let (_serialized, regions, _account_lengths) = serialize_parameters(
-                &instruction_context,
-                true,
-                false, // account_data_direct_mapping
-                mask_out_rent_epoch_in_vm_serialization,
-            )
-            .unwrap();
+            let (_serialized, regions, _account_lengths, _instruction_data_offset) =
+                serialize_parameters(
+                    &instruction_context,
+                    true,
+                    false, // account_data_direct_mapping
+                    mask_out_rent_epoch_in_vm_serialization,
+                )
+                .unwrap();
             let mut serialized_regions = concat_regions(&regions);
 
             let (_de_program_id, de_accounts, _de_instruction_data) = unsafe {

program-test/src/lib.rs

@@ -131,12 +131,13 @@ pub fn invoke_builtin_function(
     let mask_out_rent_epoch_in_vm_serialization = invoke_context
         .get_feature_set()
         .mask_out_rent_epoch_in_vm_serialization;
-    let (mut parameter_bytes, _regions, _account_lengths) = serialize_parameters(
-        &instruction_context,
-        false, // There is no VM so stricter_abi_and_runtime_constraints can not be implemented here
-        false, // There is no VM so account_data_direct_mapping can not be implemented here
-        mask_out_rent_epoch_in_vm_serialization,
-    )?;
+    let (mut parameter_bytes, _regions, _account_lengths, _instruction_data_offset) =
+        serialize_parameters(
+            &instruction_context,
+            false, // There is no VM so stricter_abi_and_runtime_constraints can not be implemented here
+            false, // There is no VM so account_data_direct_mapping can not be implemented here
+            mask_out_rent_epoch_in_vm_serialization,
+        )?;
 
     // Deserialize data back into instruction params
     let (program_id, account_infos, input) =

programs/bpf_loader/src/lib.rs

@@ -1466,14 +1466,18 @@ fn execute<'a, 'b: 'a>(
     let mask_out_rent_epoch_in_vm_serialization = invoke_context
         .get_feature_set()
         .mask_out_rent_epoch_in_vm_serialization;
+    let provide_instruction_data_offset_in_vm_r2 = invoke_context
+        .get_feature_set()
+        .provide_instruction_data_offset_in_vm_r2;
 
     let mut serialize_time = Measure::start("serialize");
-    let (parameter_bytes, regions, accounts_metadata) = serialization::serialize_parameters(
-        &instruction_context,
-        stricter_abi_and_runtime_constraints,
-        invoke_context.account_data_direct_mapping,
-        mask_out_rent_epoch_in_vm_serialization,
-    )?;
+    let (parameter_bytes, regions, accounts_metadata, instruction_data_offset) =
+        serialization::serialize_parameters(
+            &instruction_context,
+            stricter_abi_and_runtime_constraints,
+            invoke_context.account_data_direct_mapping,
+            mask_out_rent_epoch_in_vm_serialization,
+        )?;
     serialize_time.stop();
 
     // save the account addresses so in case we hit an AccessViolation error we
@@ -1508,6 +1512,11 @@ fn execute<'a, 'b: 'a>(
 
         vm.context_object_pointer.execute_time = Some(Measure::start("execute"));
         vm.registers[1] = ebpf::MM_INPUT_START;
+
+        // SIMD-0321: Provide offset to instruction data in VM register 2.
+        if provide_instruction_data_offset_in_vm_r2 {
+            vm.registers[2] = instruction_data_offset as u64;
+        }
         let (compute_units_consumed, result) = vm.execute_program(executable, !use_jit);
         MEMORY_POOL.with_borrow_mut(|memory_pool| {
             memory_pool.put_stack(stack);