Fix ldc opcode in internal contexts

CHANGELOG.md

@@ -19,6 +19,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - [#725](https://github.com/FuelLabs/fuel-vm/pull/725): `UtxoId::from_str` now rejects inputs with multiple `0x` prefixes. Many `::from_str` implementations also reject extra data in the end of the input, instead of silently ignoring it. `UtxoId::from_str` allows a single `:` between the fields. Unused `GasUnit` struct removed.
 - [#726](https://github.com/FuelLabs/fuel-vm/pull/726): Removed code related to Binary Merkle Sum Trees (BMSTs). The BMST is deprecated and not used in production environments. 
 - [#729](https://github.com/FuelLabs/fuel-vm/pull/729): Removed default implementation of `Node::key_size_bits`, implementors must now define it themselves. Also some helper traits have been merged together, or their types changed.
+- [#736](https://github.com/FuelLabs/fuel-vm/pull/736): Bugfix: LDC instruction now works in internal contexts as well.
 
 ## [Version 0.49.0]
 

fuel-types/src/bytes.rs

@@ -22,6 +22,19 @@ pub const fn padded_len_usize(len: usize) -> Option<usize> {
     }
 }
 
+/// Return the word-padded length of an arbitrary length.
+/// Returns None if the length is too large to be represented as `Word`.
+#[allow(clippy::arithmetic_side_effects)] // Safety: (a % b) < b
+pub const fn padded_len_word(len: Word) -> Option<Word> {
+    let modulo = len % WORD_SIZE as Word;
+    if modulo == 0 {
+        Some(len)
+    } else {
+        let padding = WORD_SIZE as Word - modulo;
+        len.checked_add(padding)
+    }
+}
+
 #[cfg(feature = "unsafe")]
 #[allow(unsafe_code)]
 /// Add a conversion from arbitrary slices into arrays

fuel-vm/src/interpreter/blockchain.rs

@@ -57,6 +57,7 @@ use fuel_tx::{
 };
 use fuel_types::{
     bytes,
+    bytes::padded_len_word,
     Address,
     AssetId,
     BlockHeight,
@@ -102,8 +103,6 @@ where
         // We will charge for the contracts size in the `load_contract_code`.
         self.gas_charge(gas_cost.base())?;
         let contract_max_size = self.contract_max_size();
-        let current_contract =
-            current_contract(&self.context, self.registers.fp(), &self.memory)?;
         let (
             SystemRegisters {
                 cgas,
@@ -119,6 +118,7 @@ where
         ) = split_registers(&mut self.registers);
         let input = LoadContractCodeCtx {
             memory: &mut self.memory,
+            context: &self.context,
             profiler: &mut self.profiler,
             storage: &mut self.storage,
             contract_max_size,
@@ -127,7 +127,6 @@ where
                 &mut self.panic_context,
             ),
             gas_cost,
-            current_contract,
             cgas,
             ggas,
             ssp,
@@ -538,10 +537,10 @@ where
 struct LoadContractCodeCtx<'vm, S, I> {
     contract_max_size: u64,
     memory: &'vm mut Memory,
+    context: &'vm Context,
     profiler: &'vm mut Profiler,
     input_contracts: InputContracts<'vm, I>,
     storage: &'vm S,
-    current_contract: Option<ContractId>,
     gas_cost: DependentCost,
     cgas: RegMut<'vm, CGAS>,
     ggas: RegMut<'vm, GGAS>,
@@ -576,7 +575,6 @@ where
     {
         let ssp = *self.ssp;
         let sp = *self.sp;
-        let fp = *self.fp;
         let region_start = ssp;
 
         if ssp != sp {
@@ -588,6 +586,8 @@ where
             .try_into()
             .map_err(|_| PanicReason::MemoryOverflow)?;
 
+        let current_contract = current_contract(self.context, self.fp, self.memory)?;
+
         let length = bytes::padded_len_usize(
             length_unpadded
                 .try_into()
@@ -612,7 +612,7 @@ where
         let profiler = ProfileGas {
             pc: self.pc.as_ref(),
             is: self.is,
-            current_contract: self.current_contract,
+            current_contract,
             profiler: self.profiler,
         };
         dependent_gas_charge_without_base(
@@ -636,19 +636,20 @@ where
             length,
         )?;
 
-        // Update frame pointer, if we have a stack frame (e.g. fp > 0)
-        if fp > 0 {
-            let size = CallFrame::code_size_offset().saturating_add(WORD_SIZE);
-
-            let old_code_size = Word::from_be_bytes(self.memory.read_bytes(fp)?);
-
+        // Update frame code size, if we have a stack frame (i.e. fp > 0)
+        if self.context.is_internal() {
+            let code_size_ptr =
+                (*self.fp).saturating_add(CallFrame::code_size_offset() as Word);
+            let old_code_size =
+                Word::from_be_bytes(self.memory.read_bytes(code_size_ptr)?);
+            let old_code_size = padded_len_word(old_code_size)
+                .expect("Code size cannot overflow with padding");
             let new_code_size = old_code_size
                 .checked_add(length as Word)
                 .ok_or(PanicReason::MemoryOverflow)?;
 
             self.memory
-                .write_noownerchecks(fp, size)?
-                .copy_from_slice(&new_code_size.to_be_bytes());
+                .write_bytes_noownerchecks(code_size_ptr, new_code_size.to_be_bytes())?;
         }
 
         inc_pc(self.pc)?;

fuel-vm/src/interpreter/blockchain/code_tests.rs

@@ -14,7 +14,7 @@ use crate::{
 use fuel_tx::Contract;
 
 #[test]
-fn test_load_contract() -> IoResult<(), Infallible> {
+fn test_load_contract_in_script() -> IoResult<(), Infallible> {
     let mut storage = MemoryStorage::default();
     let mut memory: Memory = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 4;
@@ -48,9 +48,67 @@ fn test_load_contract() -> IoResult<(), Infallible> {
         contract_max_size: 100,
         storage: &storage,
         memory: &mut memory,
+        context: &Context::Script {
+            block_height: Default::default(),
+        },
+        profiler: &mut Profiler::default(),
+        input_contracts: InputContracts::new(input_contracts.iter(), &mut panic_context),
+        gas_cost: DependentCost::from_units_per_gas(13, 1),
+        cgas: RegMut::new(&mut cgas),
+        ggas: RegMut::new(&mut ggas),
+        ssp: RegMut::new(&mut ssp),
+        sp: RegMut::new(&mut sp),
+        fp: Reg::new(&fp),
+        pc: RegMut::new(&mut pc),
+        is: Reg::new(&is),
+    };
+    input.load_contract_code(contract_id_mem_address, offset, num_bytes)?;
+    assert_eq!(pc, 8);
+    assert_eq!(cgas, 1000 - CONTRACT_SIZE /* price per byte */);
+    assert_eq!(ggas, 1000 - CONTRACT_SIZE /* price per byte */);
+
+    Ok(())
+}
+#[test]
+fn test_load_contract_in_call() -> IoResult<(), Infallible> {
+    let mut storage = MemoryStorage::default();
+    let mut memory: Memory = vec![1u8; MEM_SIZE].try_into().unwrap();
+    let mut pc = 4;
+    let mut cgas = 1000;
+    let mut ggas = 1000;
+    let mut ssp = 1000;
+    let mut sp = 1000;
+    let fp = 32;
+    let is = 0;
+
+    let contract_id = ContractId::from([4u8; 32]);
+
+    let contract_id_mem_address: Word = 32;
+    let offset = 20;
+    let num_bytes = 40;
+    const CONTRACT_SIZE: u64 = 400;
+
+    memory[contract_id_mem_address as usize
+        ..contract_id_mem_address as usize + ContractId::LEN]
+        .copy_from_slice(contract_id.as_ref());
+    storage
+        .storage_contract_insert(
+            &contract_id,
+            &Contract::from(vec![5u8; CONTRACT_SIZE as usize]),
+        )
+        .unwrap();
+
+    let mut panic_context = PanicContext::None;
+    let input_contracts = [contract_id];
+    let input = LoadContractCodeCtx {
+        contract_max_size: 100,
+        storage: &storage,
+        memory: &mut memory,
+        context: &Context::Call {
+            block_height: Default::default(),
+        },
         profiler: &mut Profiler::default(),
         input_contracts: InputContracts::new(input_contracts.iter(), &mut panic_context),
-        current_contract: None,
         gas_cost: DependentCost::from_units_per_gas(13, 1),
         cgas: RegMut::new(&mut cgas),
         ggas: RegMut::new(&mut ggas),

fuel-vm/src/interpreter/internal.rs

@@ -186,7 +186,7 @@ pub(crate) fn current_contract(
     memory: &Memory,
 ) -> Result<Option<ContractId>, PanicReason> {
     if context.is_internal() {
-        Ok(Some(internal_contract(context, fp, memory)?))
+        Ok(Some(ContractId::new(memory.read_bytes(*fp)?)))
     } else {
         Ok(None)
     }
@@ -197,11 +197,7 @@ pub(crate) fn internal_contract(
     fp: Reg<FP>,
     memory: &Memory,
 ) -> Result<ContractId, PanicReason> {
-    if context.is_internal() {
-        Ok(ContractId::new(memory.read_bytes(*fp)?))
-    } else {
-        Err(PanicReason::ExpectedInternalContext)
-    }
+    current_contract(context, fp, memory)?.ok_or(PanicReason::ExpectedInternalContext)
 }
 
 pub(crate) fn set_frame_pointer(