diff --git a/crates/polkavm-common/src/program.rs b/crates/polkavm-common/src/program.rs
index 19ab0b24..6b9d2e79 100644
--- a/crates/polkavm-common/src/program.rs
+++ b/crates/polkavm-common/src/program.rs
@@ -1,4 +1,5 @@
 use crate::abi::{VM_CODE_ADDRESS_ALIGNMENT, VM_MAXIMUM_CODE_SIZE, VM_MAXIMUM_IMPORT_COUNT, VM_MAXIMUM_JUMP_TABLE_ENTRIES};
+use crate::cast::cast;
 use crate::utils::ArcBytes;
 use crate::varint::{read_simple_varint, read_varint, write_simple_varint, MAX_VARINT_LENGTH};
 use core::fmt::Write;
@@ -8,6 +9,9 @@ use core::ops::Range;
 #[repr(transparent)]
 pub struct RawReg(u32);
 
+#[cfg(feature = "alloc")]
+use crate::abi::MemoryMapBuilder;
+
 impl Eq for RawReg {}
 impl PartialEq for RawReg {
     fn eq(&self, rhs: &Self) -> bool {
@@ -444,6 +448,27 @@ impl LookupTable {
     }
 }
 
+pub const INTERPRETER_CACHE_ENTRY_SIZE: u32 = {
+    if cfg!(target_pointer_width = "32") {
+        20
+    } else if cfg!(target_pointer_width = "64") {
+        24
+    } else {
+        panic!("unsupported target pointer width")
+    }
+};
+
+pub const INTERPRETER_CACHE_RESERVED_ENTRIES: u32 = 10;
+pub const INTERPRETER_FLATMAP_ENTRY_SIZE: u32 = 4;
+
+pub fn interpreter_calculate_cache_size(count: usize) -> usize {
+    count * INTERPRETER_CACHE_ENTRY_SIZE as usize
+}
+
+pub fn interpreter_calculate_cache_num_entries(bytes: usize) -> usize {
+    bytes / INTERPRETER_CACHE_ENTRY_SIZE as usize
+}
+
 static TABLE_1: LookupTable = LookupTable::build(1);
 static TABLE_2: LookupTable = LookupTable::build(2);
 
@@ -737,6 +762,19 @@ mod kani {
         let reg2 = reg2.get() as u8;
         assert_eq!((reg1, reg2), simple_read_args_regs2(&code));
     }
+
+    #[kani::proof]
+    fn verify_interpreter_cache_size() {
+        let x: usize = kani::any_where(|x| *x <= super::cast(u32::MAX).to_usize());
+        let bytes: usize = super::interpreter_calculate_cache_size(x);
+        let calculate_count = super::interpreter_calculate_cache_num_entries(bytes);
+        assert_eq!(calculate_count, x);
+
+        let count = super::interpreter_calculate_cache_num_entries(x);
+        let calculated_bytes = super::interpreter_calculate_cache_size(count);
+        assert!(calculated_bytes <= x);
+        assert!(x - calculated_bytes <= super::interpreter_calculate_cache_size(1));
+    }
 }
 
 /// The lowest level visitor; dispatches directly on opcode numbers.
@@ -1864,8 +1902,6 @@ impl<'a, 'b, 'c> InstructionFormatter<'a, 'b, 'c> {
 
         impl core::fmt::Display for Formatter {
             fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
-                use crate::cast::cast;
-
                 if self.imm == 0 {
                     write!(fmt, "{}", self.imm)
                 } else if !self.is_64_bit {
@@ -4165,6 +4201,28 @@ fn test_instructions_iterator_does_not_emit_unnecessary_invalid_instructions_if_
     assert_eq!(i.next(), None);
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum EstimateInterpreterMemoryUsageArgs {
+    UnboundedCache {
+        instruction_count: u32,
+        basic_block_count: u32,
+        page_size: u32,
+    },
+    BoundedCache {
+        instruction_count: u32,
+        basic_block_count: u32,
+        max_cache_size_bytes: u32,
+        max_block_size: u32,
+        page_size: u32,
+    },
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct ProgramMemoryInfo {
+    pub baseline_ram_consumption: u32,
+    pub purgeable_ram_consumption: u32,
+}
+
 #[derive(Clone, Default)]
 #[non_exhaustive]
 pub struct ProgramParts {
@@ -4726,6 +4784,140 @@ impl ProgramBlob {
             mutation_depth: 0,
         }))
     }
+
+    #[cfg(feature = "alloc")]
+    pub(crate) fn calculate_blob_length(&self) -> u64 {
+        let ProgramBlob {
+            #[cfg(feature = "unique-id")]
+                unique_id: _,
+            is_64_bit: _,
+            ro_data_size: _,
+            rw_data_size: _,
+            stack_size: _,
+            ro_data,
+            rw_data,
+            code,
+            jump_table,
+            jump_table_entry_size: _,
+            bitmask,
+            import_offsets,
+            import_symbols,
+            exports,
+            debug_strings,
+            debug_line_program_ranges,
+            debug_line_programs,
+        } = self;
+
+        let mut ranges = [
+            ro_data.parent_address_range(),
+            rw_data.parent_address_range(),
+            code.parent_address_range(),
+            jump_table.parent_address_range(),
+            bitmask.parent_address_range(),
+            import_offsets.parent_address_range(),
+            import_symbols.parent_address_range(),
+            exports.parent_address_range(),
+            debug_strings.parent_address_range(),
+            debug_line_program_ranges.parent_address_range(),
+            debug_line_programs.parent_address_range(),
+        ];
+
+        ranges.sort_unstable_by_key(|r| r.start);
+
+        let mut blob_length = 0;
+        let mut last_range = 0..0;
+        for range in ranges {
+            if range == last_range {
+                continue;
+            }
+            blob_length += cast(range.len()).to_u64();
+            last_range = range;
+        }
+        blob_length
+    }
+
+    #[cfg(feature = "alloc")]
+    pub fn estimate_interpreter_memory_usage(&self, args: EstimateInterpreterMemoryUsageArgs) -> Result<ProgramMemoryInfo, &'static str> {
+        let (page_size, instruction_count, basic_block_count) = match args {
+            EstimateInterpreterMemoryUsageArgs::UnboundedCache {
+                page_size,
+                instruction_count,
+                basic_block_count,
+                ..
+            } => (page_size, instruction_count, basic_block_count),
+            EstimateInterpreterMemoryUsageArgs::BoundedCache {
+                page_size,
+                instruction_count,
+                basic_block_count,
+                ..
+            } => (page_size, instruction_count, basic_block_count),
+        };
+
+        let cache_entry_count_upper_bound = cast(instruction_count + basic_block_count + INTERPRETER_CACHE_RESERVED_ENTRIES).to_usize();
+        let cache_size_upper_bound = interpreter_calculate_cache_size(cache_entry_count_upper_bound);
+
+        let mut purgeable_ram_consumption = match args {
+            EstimateInterpreterMemoryUsageArgs::UnboundedCache { .. } => cache_size_upper_bound,
+            EstimateInterpreterMemoryUsageArgs::BoundedCache {
+                max_cache_size_bytes,
+                max_block_size,
+                ..
+            } => {
+                let max_cache_size_bytes = cast(max_cache_size_bytes).to_usize();
+                let cache_entry_count_hard_limit = cast(max_block_size + INTERPRETER_CACHE_RESERVED_ENTRIES).to_usize();
+                let cache_bytes_hard_limit = interpreter_calculate_cache_size(cache_entry_count_hard_limit);
+                if cache_bytes_hard_limit > max_cache_size_bytes {
+                    return Err("maximum cache size is too small for the given max block size");
+                }
+
+                max_cache_size_bytes.min(cache_size_upper_bound)
+            }
+        };
+
+        let code_length = self.code.len();
+        purgeable_ram_consumption = purgeable_ram_consumption.saturating_add((code_length + 1) * INTERPRETER_FLATMAP_ENTRY_SIZE as usize);
+
+        let Ok(purgeable_ram_consumption) = u32::try_from(purgeable_ram_consumption) else {
+            return Err("estimated interpreter cache size is too large");
+        };
+
+        let memory_map = MemoryMapBuilder::new(page_size)
+            .ro_data_size(self.ro_data_size)
+            .rw_data_size(self.rw_data_size)
+            .stack_size(self.stack_size)
+            .build()?;
+
+        let blob_length = self.calculate_blob_length();
+        let Ok(baseline_ram_consumption) = u32::try_from(
+            blob_length
+                .saturating_add(u64::from(memory_map.ro_data_size()))
+                .saturating_sub(self.ro_data.len() as u64)
+                .saturating_add(u64::from(memory_map.rw_data_size()))
+                .saturating_sub(self.rw_data.len() as u64)
+                .saturating_add(u64::from(memory_map.stack_size())),
+        ) else {
+            return Err("calculated baseline RAM consumption is too large");
+        };
+
+        Ok(ProgramMemoryInfo {
+            baseline_ram_consumption,
+            purgeable_ram_consumption,
+        })
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn test_calculate_blob_length() {
+    let big_blob = ArcBytes::from(vec![0; 1024]);
+    let shared_blob = ArcBytes::from(vec![0; 128]);
+    let parts = ProgramParts {
+        ro_data: big_blob.subslice(10..20),
+        rw_data: big_blob.subslice(24..28),
+        code_and_jump_table: shared_blob.clone(),
+        ..ProgramParts::default()
+    };
+    assert_eq!(parts.calculate_blob_length(), 1024 + 128);
 }
 
 /// The source location.
diff --git a/crates/polkavm-common/src/utils.rs b/crates/polkavm-common/src/utils.rs
index 82d99ffe..0041f22c 100644
--- a/crates/polkavm-common/src/utils.rs
+++ b/crates/polkavm-common/src/utils.rs
@@ -12,13 +12,8 @@ use alloc::{borrow::Cow, sync::Arc, vec::Vec};
 #[derive(Clone)]
 enum LifetimeObject {
     None,
-    Arc {
-        _obj: Arc<[u8]>,
-    },
-    #[allow(dyn_drop)]
-    Other {
-        _obj: Arc<dyn Drop>,
-    },
+    Arc { obj: Arc<[u8]> },
+    Other { obj: Arc<dyn AsRef<[u8]>> },
 }
 
 #[derive(Clone)]
@@ -89,6 +84,16 @@ impl ArcBytes {
             lifetime: self.lifetime.clone(),
         }
     }
+
+    #[cfg(feature = "alloc")]
+    pub(crate) fn parent_address_range(&self) -> Range<usize> {
+        let slice = match &self.lifetime {
+            LifetimeObject::None => return 0..0,
+            LifetimeObject::Arc { obj } => obj.as_ref(),
+            LifetimeObject::Other { obj } => obj.as_ref().as_ref(),
+        };
+        slice.as_ptr() as usize..(slice.as_ptr() as usize + slice.len())
+    }
 }
 
 impl Eq for ArcBytes {}
@@ -135,7 +140,7 @@ impl From<Vec<u8>> for ArcBytes {
         ArcBytes {
             pointer: core::ptr::NonNull::new(data.as_ptr().cast_mut()).unwrap(),
             length: data.len(),
-            lifetime: LifetimeObject::Other { _obj: Arc::new(data) },
+            lifetime: LifetimeObject::Other { obj: Arc::new(data) },
         }
     }
 }
@@ -146,7 +151,7 @@ impl From<Arc<[u8]>> for ArcBytes {
         ArcBytes {
             pointer: core::ptr::NonNull::new(data.deref().as_ptr().cast_mut()).unwrap(),
             length: data.len(),
-            lifetime: LifetimeObject::Arc { _obj: data },
+            lifetime: LifetimeObject::Arc { obj: data },
         }
     }
 }
diff --git a/crates/polkavm/src/api.rs b/crates/polkavm/src/api.rs
index 1d13cbf0..c0c41119 100644
--- a/crates/polkavm/src/api.rs
+++ b/crates/polkavm/src/api.rs
@@ -83,6 +83,13 @@ impl<T> IntoResult<T> for T {
 
 pub type RegValue = u64;
 
+#[allow(clippy::exhaustive_structs)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct SetCacheSizeLimitArgs {
+    pub max_block_size: u32,
+    pub max_cache_size_bytes: usize,
+}
+
 #[derive(Copy, Clone)]
 pub struct RuntimeInstructionSet {
     allow_sbrk: bool,
@@ -1715,4 +1722,13 @@ impl RawInstance {
             backend.reset_interpreter_cache();
         }
     }
+
+    /// Set a tight upper limit on the interpreter cache size (in bytes).
+    pub fn set_interpreter_cache_size_limit(&mut self, cache_info: Option<SetCacheSizeLimitArgs>) -> Result<(), Error> {
+        #[allow(irrefutable_let_patterns)]
+        if let InstanceBackend::Interpreted(ref mut backend) = self.backend {
+            backend.set_interpreter_cache_size_limit(cache_info)?
+        }
+        Ok(())
+    }
 }
diff --git a/crates/polkavm/src/compiler.rs b/crates/polkavm/src/compiler.rs
index 0d83c2b0..b8f8bcbe 100644
--- a/crates/polkavm/src/compiler.rs
+++ b/crates/polkavm/src/compiler.rs
@@ -43,7 +43,7 @@ const END_BASIC_BLOCK_INVALID: usize = 2;
 
 struct CachePerCompilation {
     assembler: Assembler,
-    program_counter_to_label: FlatMap<Label>,
+    program_counter_to_label: FlatMap<Label, false>,
     gas_metering_stub_offsets: Vec<usize>,
     gas_cost_for_basic_block: Vec<u32>,
     export_to_label: HashMap<u32, Label>,
@@ -93,7 +93,7 @@ where
     code: &'a [u8],
     bitmask: &'a [u8],
     asm: Assembler,
-    program_counter_to_label: FlatMap<Label>,
+    program_counter_to_label: FlatMap<Label, false>,
     step_tracing: bool,
     ecall_label: Label,
     export_to_label: HashMap<u32, Label>,
diff --git a/crates/polkavm/src/interpreter.rs b/crates/polkavm/src/interpreter.rs
index af06819f..035b5e8c 100644
--- a/crates/polkavm/src/interpreter.rs
+++ b/crates/polkavm/src/interpreter.rs
@@ -1,7 +1,7 @@
 #![allow(unknown_lints)] // Because of `non_local_definitions` on older rustc versions.
 #![allow(non_local_definitions)]
 #![deny(clippy::as_conversions)]
-use crate::api::{MemoryAccessError, Module, RegValue};
+use crate::api::{MemoryAccessError, Module, RegValue, SetCacheSizeLimitArgs};
 use crate::error::Error;
 use crate::gas::GasVisitor;
 use crate::utils::{FlatMap, GuestInit, InterruptKind, Segfault};
@@ -15,7 +15,10 @@ use core::num::NonZeroU32;
 use polkavm_common::abi::VM_ADDR_RETURN_TO_HOST;
 use polkavm_common::cast::cast;
 use polkavm_common::operation::*;
-use polkavm_common::program::{asm, InstructionVisitor, RawReg, Reg};
+use polkavm_common::program::{
+    asm, interpreter_calculate_cache_num_entries, InstructionVisitor, RawReg, Reg, INTERPRETER_CACHE_ENTRY_SIZE,
+    INTERPRETER_CACHE_RESERVED_ENTRIES, INTERPRETER_FLATMAP_ENTRY_SIZE,
+};
 use polkavm_common::utils::{align_to_next_page_usize, byte_slice_init, slice_assume_init_mut};
 
 type Target = u32;
@@ -394,6 +397,14 @@ fn test_each_page() {
     ]);
 }
 
+use NonZeroU32 as CompiledOffset;
+
+polkavm_common::static_assert!(
+    core::mem::size_of::<Handler>() + core::mem::size_of::<Args>() == cast(INTERPRETER_CACHE_ENTRY_SIZE).to_usize()
+);
+
+polkavm_common::static_assert!(core::mem::size_of::<CompiledOffset>() == cast(INTERPRETER_FLATMAP_ENTRY_SIZE).to_usize());
+
 pub(crate) struct InterpretedInstance {
     module: Module,
     basic_memory: BasicMemory,
@@ -405,13 +416,15 @@ pub(crate) struct InterpretedInstance {
     next_program_counter_changed: bool,
     cycle_counter: u64,
     gas: i64,
-    compiled_offset_for_block: FlatMap<NonZeroU32>,
+    compiled_offset_for_block: FlatMap<CompiledOffset, true>,
     compiled_handlers: Vec<Handler>,
     compiled_args: Vec<Args>,
     compiled_offset: u32,
     interrupt: InterruptKind,
     step_tracing: bool,
     unresolved_program_counter: Option<ProgramCounter>,
+    min_compiled_handlers: usize,
+    max_compiled_handlers: Option<usize>,
 }
 
 impl InterpretedInstance {
@@ -435,6 +448,8 @@ impl InterpretedInstance {
             interrupt: InterruptKind::Finished,
             step_tracing,
             unresolved_program_counter: None,
+            min_compiled_handlers: 0,
+            max_compiled_handlers: None,
         };
 
         instance.initialize_module();
@@ -469,6 +484,40 @@ impl InterpretedInstance {
         self.gas = gas;
     }
 
+    pub fn set_interpreter_cache_size_limit(&mut self, cache_info: Option<SetCacheSizeLimitArgs>) -> Result<(), Error> {
+        let Some(SetCacheSizeLimitArgs {
+            max_block_size,
+            max_cache_size_bytes,
+        }) = cache_info
+        else {
+            self.max_compiled_handlers = None;
+            return Ok(());
+        };
+
+        let compiled_handlers_hard_limit = interpreter_calculate_cache_num_entries(max_cache_size_bytes);
+
+        // Calculate the minimum number of compiled handlers required to guarantee a tight upper bound.
+        // We must be able to hold at least two basic blocks (including gas metering) and we should also account for precompiled stubs.
+        let minimum_compiled_handlers = cast((max_block_size + 1) * 2 + INTERPRETER_CACHE_RESERVED_ENTRIES).to_usize();
+
+        if compiled_handlers_hard_limit < minimum_compiled_handlers {
+            log::debug!(
+                "interpreter cache size is too small to gurantee a tight upper bound: {} < {}; max_block_size={}, max_cache_size_bytes={}",
+                compiled_handlers_hard_limit,
+                minimum_compiled_handlers,
+                max_block_size,
+                max_cache_size_bytes
+            );
+            return Err(Error::from(
+                "given maximum cache size is too small to guarantee a tight upper bound",
+            ));
+        }
+
+        let compiled_handlers_soft_limit = compiled_handlers_hard_limit - cast(max_block_size + 1).to_usize();
+        self.max_compiled_handlers = Some(compiled_handlers_soft_limit);
+        Ok(())
+    }
+
     pub fn program_counter(&self) -> Option<ProgramCounter> {
         if !self.program_counter_valid {
             None
@@ -783,6 +832,8 @@ impl InterpretedInstance {
         }
 
         self.compile_out_of_range_stub();
+        self.min_compiled_handlers = self.compiled_handlers.len();
+        debug_assert!(self.min_compiled_handlers <= cast(INTERPRETER_CACHE_RESERVED_ENTRIES).to_usize());
     }
 
     #[inline(always)]
@@ -932,6 +983,38 @@ impl InterpretedInstance {
             }
         }
 
+        if let Some(max_compiled_handlers) = self.max_compiled_handlers {
+            let handlers_added = self.compiled_handlers.len() - cast(origin).to_usize();
+            if handlers_added + self.min_compiled_handlers > max_compiled_handlers {
+                let compiled_handlers_new_limit = handlers_added + self.min_compiled_handlers;
+
+                log::warn!(
+                    "interpreter: compiled handlers cache is too small: {} + {} > {}; setting new limit to {} and resetting the cache",
+                    handlers_added,
+                    self.min_compiled_handlers,
+                    max_compiled_handlers,
+                    compiled_handlers_new_limit
+                );
+
+                self.max_compiled_handlers = Some(compiled_handlers_new_limit);
+                self.compiled_handlers[cast(origin).to_usize()] = cast_handler!(raw_handlers::reset_cache::<DEBUG>);
+                self.compiled_args[cast(origin).to_usize()] = Args::reset_cache(program_counter);
+            } else if self.compiled_handlers.len() > max_compiled_handlers {
+                log::debug!(
+                    "interpreter: compiled handlers cache size exceeded at {}: {} > {}; will reset the cache",
+                    origin,
+                    self.compiled_handlers.len(),
+                    max_compiled_handlers
+                );
+
+                self.compiled_handlers[cast(origin).to_usize()] = cast_handler!(raw_handlers::reset_cache::<DEBUG>);
+                self.compiled_args[cast(origin).to_usize()] = Args::reset_cache(program_counter);
+            } else if self.compiled_handlers.capacity() > max_compiled_handlers {
+                self.compiled_handlers.shrink_to(max_compiled_handlers);
+                self.compiled_args.shrink_to(max_compiled_handlers);
+            }
+        }
+
         if let Some((program_counter, index)) = charge_gas_index {
             let gas_cost = gas_visitor.take_block_cost().unwrap();
             self.compiled_args[index] = Args::charge_gas(program_counter, gas_cost);
@@ -2040,6 +2123,15 @@ define_interpreter! {
         None
     }
 
+    fn reset_cache<const DEBUG: bool>(visitor: &mut Visitor, program_counter: ProgramCounter) -> Option<Target> {
+        if DEBUG {
+            log::trace!("[{}]: reset_cache", visitor.inner.compiled_offset);
+        }
+
+        visitor.inner.reset_interpreter_cache();
+        visitor.inner.compile_block::<DEBUG>(program_counter)
+    }
+
     fn fallthrough<const DEBUG: bool>(visitor: &mut Visitor) -> Option<Target> {
         if DEBUG {
             log::trace!("[{}]: fallthrough", visitor.inner.compiled_offset);
diff --git a/crates/polkavm/src/lib.rs b/crates/polkavm/src/lib.rs
index c0d3d1f6..d6c5f61d 100644
--- a/crates/polkavm/src/lib.rs
+++ b/crates/polkavm/src/lib.rs
@@ -131,14 +131,15 @@ pub mod debug_info {
 /// Miscellaneous types related to program blobs.
 pub mod program {
     pub use polkavm_common::program::{
-        ISA32_V1_NoSbrk, Imports, ImportsIter, Instruction, InstructionSet, Instructions, JumpTable, JumpTableIter, Opcode,
-        ParsedInstruction, ProgramExport, ProgramParseError, ProgramSymbol, RawReg, ISA32_V1, ISA64_V1,
+        EstimateInterpreterMemoryUsageArgs, ISA32_V1_NoSbrk, Imports, ImportsIter, Instruction, InstructionSet, Instructions, JumpTable,
+        JumpTableIter, Opcode, ParsedInstruction, ProgramExport, ProgramMemoryInfo, ProgramParseError, ProgramSymbol, RawReg, ISA32_V1,
+        ISA64_V1,
     };
 }
 
 pub type Gas = i64;
 
-pub use crate::api::{Engine, MemoryAccessError, Module, RawInstance, RegValue};
+pub use crate::api::{Engine, MemoryAccessError, Module, RawInstance, RegValue, SetCacheSizeLimitArgs};
 pub use crate::config::{BackendKind, Config, CustomCodegen, GasMeteringKind, ModuleConfig, SandboxKind};
 pub use crate::error::Error;
 pub use crate::gas::{Cost, CostModel, CostModelRef};
diff --git a/crates/polkavm/src/tests.rs b/crates/polkavm/src/tests.rs
index 96f1f9b8..f1b3e692 100644
--- a/crates/polkavm/src/tests.rs
+++ b/crates/polkavm/src/tests.rs
@@ -1,7 +1,7 @@
 use crate::mutex::Mutex;
 use crate::{
     BackendKind, CallError, Caller, Config, Engine, GasMeteringKind, InterruptKind, Linker, MemoryAccessError, Module, ModuleConfig,
-    ProgramBlob, ProgramCounter, Reg, Segfault,
+    ProgramBlob, ProgramCounter, Reg, Segfault, SetCacheSizeLimitArgs,
 };
 use alloc::collections::BTreeMap;
 use alloc::format;
@@ -11,7 +11,7 @@ use alloc::vec::Vec;
 
 use polkavm_common::abi::MemoryMapBuilder;
 use polkavm_common::program::{asm, DefaultInstructionSet};
-use polkavm_common::program::{BlobLen, Reg::*};
+use polkavm_common::program::{BlobLen, Reg::*, INTERPRETER_CACHE_ENTRY_SIZE, INTERPRETER_CACHE_RESERVED_ENTRIES};
 use polkavm_common::utils::align_to_next_page_u32;
 use polkavm_common::writer::ProgramBlobBuilder;
 
@@ -516,6 +516,145 @@ fn reclaim_cache_memory(config: Config) {
     assert_eq!(instance.reg(Reg::A2), 0x4567);
 }
 
+fn bounded_interpreter_cache(config: Config) {
+    // this test is only relevant for the interpreter backend
+    if config.backend() != Some(crate::BackendKind::Interpreter) {
+        return;
+    }
+
+    let _ = env_logger::try_init();
+    let engine = Engine::new(&config).unwrap();
+    let mut builder = ProgramBlobBuilder::new();
+    builder.add_export_by_basic_block(0, b"entry_0");
+    builder.add_export_by_basic_block(1, b"entry_1");
+    builder.add_export_by_basic_block(2, b"entry_2");
+    builder.add_export_by_basic_block(3, b"entry_3");
+    builder.add_export_by_basic_block(4, b"entry_4");
+    builder.add_export_by_basic_block(5, b"entry_5");
+
+    // 0 -> 4 -> 1 -> 3 -> 2 -> 5
+    builder.set_code(
+        &[
+            asm::add_imm_32(A0, A0, 0x1),
+            asm::jump(4),
+            asm::add_imm_32(A1, A1, 0x1),
+            asm::add_imm_32(A1, A1, 0x10),
+            asm::add_imm_32(A1, A1, 0x100),
+            asm::add_imm_32(A1, A1, 0x1),
+            asm::add_imm_32(A1, A1, 0x10),
+            asm::add_imm_32(A1, A1, 0x100),
+            asm::jump(3),
+            asm::add_imm_32(A2, A2, 0x1),
+            asm::add_imm_32(A2, A2, 0x10),
+            asm::add_imm_32(A2, A2, 0x100),
+            asm::add_imm_32(A2, A2, 0x1000),
+            asm::add_imm_32(A2, A2, 0x1),
+            asm::add_imm_32(A2, A2, 0x10),
+            asm::add_imm_32(A2, A2, 0x100),
+            asm::add_imm_32(A2, A2, 0x1000),
+            asm::add_imm_32(A2, A2, 0x1),
+            asm::add_imm_32(A2, A2, 0x10),
+            asm::add_imm_32(A2, A2, 0x100),
+            asm::add_imm_32(A2, A2, 0x1000),
+            asm::jump(5),
+            asm::add_imm_32(A3, A3, 0x1),
+            asm::add_imm_32(A3, A3, 0x10),
+            asm::add_imm_32(A3, A3, 0x100),
+            asm::add_imm_32(A3, A3, 0x1),
+            asm::add_imm_32(A3, A3, 0x10),
+            asm::add_imm_32(A3, A3, 0x100),
+            asm::jump(2),
+            asm::add_imm_32(A4, A4, 0x1),
+            asm::add_imm_32(A4, A4, 0x10),
+            asm::jump(1),
+            asm::load_imm(A5, 0x1),
+            asm::ret(),
+        ],
+        &[],
+    );
+
+    let blob = ProgramBlob::parse(builder.into_vec().unwrap().into()).unwrap();
+    let module = Module::from_blob(&engine, &ModuleConfig::new(), blob).unwrap();
+    let exports: Vec<_> = module.exports().map(|export| export.program_counter()).collect();
+
+    let mut instance = module.instantiate().unwrap();
+
+    assert_eq!(INTERPRETER_CACHE_ENTRY_SIZE, 24);
+    assert_eq!(INTERPRETER_CACHE_RESERVED_ENTRIES, 10);
+
+    let minimum_cache_size = 24 * (10 + 2);
+
+    for max_cache_size_bytes in 0..minimum_cache_size {
+        log::debug!("Testing with max_cache_size_bytes: {}", max_cache_size_bytes);
+        assert!(instance
+            .set_interpreter_cache_size_limit(Some(SetCacheSizeLimitArgs {
+                max_block_size: 0,
+                max_cache_size_bytes,
+            }))
+            .is_err());
+    }
+
+    assert!(instance
+        .set_interpreter_cache_size_limit(Some(SetCacheSizeLimitArgs {
+            max_block_size: 0,
+            max_cache_size_bytes: minimum_cache_size,
+        }))
+        .is_ok());
+
+    for (max_block_size, max_cache_size_bytes) in [(0, 24 * 12), (5, 24 * 22), (12, 1000000)] {
+        for start_block in 0..exports.len() {
+            log::debug!(
+                "Testing with max_block_size: {}, max_cache_size_bytes: {}, start_block: {}",
+                max_block_size,
+                max_cache_size_bytes,
+                start_block
+            );
+
+            instance.set_reg(Reg::RA, crate::RETURN_TO_HOST);
+            instance.set_reg(Reg::A0, 0);
+            instance.set_reg(Reg::A1, 0);
+            instance.set_reg(Reg::A2, 0);
+            instance.set_reg(Reg::A3, 0);
+            instance.set_reg(Reg::A4, 0);
+            instance.set_reg(Reg::A5, 0);
+            instance.set_next_program_counter(exports[start_block]);
+
+            assert!(instance
+                .set_interpreter_cache_size_limit(Some(SetCacheSizeLimitArgs {
+                    max_block_size,
+                    max_cache_size_bytes,
+                }))
+                .is_ok());
+
+            match_interrupt!(instance.run().unwrap(), InterruptKind::Finished);
+
+            if start_block == 0 {
+                assert_eq!(instance.reg(Reg::A0), 0x1);
+            }
+
+            if matches!(start_block, 0 | 1 | 4) {
+                assert_eq!(instance.reg(Reg::A1), 0x222);
+            }
+
+            if matches!(start_block, 0 | 1 | 2 | 3 | 4) {
+                assert_eq!(instance.reg(Reg::A2), 0x3333);
+            }
+
+            if matches!(start_block, 0 | 1 | 3 | 4) {
+                assert_eq!(instance.reg(Reg::A3), 0x222);
+            }
+
+            if matches!(start_block, 0 | 4) {
+                assert_eq!(instance.reg(Reg::A4), 0x11);
+            }
+
+            if matches!(start_block, 0 | 1 | 2 | 3 | 4 | 5) {
+                assert_eq!(instance.reg(Reg::A5), 0x1);
+            }
+        }
+    }
+}
+
 fn step_tracing_invalid_store(engine_config: Config) {
     let _ = env_logger::try_init();
     let engine = Engine::new(&engine_config).unwrap();
@@ -3942,6 +4081,7 @@ run_tests! {
     out_of_range_execution
 
     reclaim_cache_memory
+    bounded_interpreter_cache
 
     memset_basic
     memset_with_dynamic_paging
diff --git a/crates/polkavm/src/utils.rs b/crates/polkavm/src/utils.rs
index c61c5174..26a29f2a 100644
--- a/crates/polkavm/src/utils.rs
+++ b/crates/polkavm/src/utils.rs
@@ -22,22 +22,28 @@ impl<'a> GuestInit<'a> {
     }
 }
 
-pub(crate) struct FlatMap<T> {
+pub(crate) struct FlatMap<T, const LAZY_ALLOCATION: bool> {
     inner: Vec<Option<T>>,
-    min_max_key: Option<(u32, u32)>,
+    desired_capacity: u32,
 }
 
-impl<T> FlatMap<T>
+impl<T, const LAZY_ALLOCATION: bool> FlatMap<T, LAZY_ALLOCATION>
 where
     T: Copy,
 {
     #[inline]
     pub fn new(capacity: u32) -> Self {
         let mut inner = Vec::new();
-        inner.reserve_exact(capacity as usize);
-        inner.resize_with(capacity as usize, || None);
 
-        Self { inner, min_max_key: None }
+        if !LAZY_ALLOCATION {
+            inner.reserve_exact(capacity as usize);
+            inner.resize_with(capacity as usize, || None);
+        }
+
+        Self {
+            inner,
+            desired_capacity: capacity,
+        }
     }
 
     #[inline]
@@ -45,7 +51,7 @@ where
     pub fn new_reusing_memory(mut memory: Self, capacity: u32) -> Self {
         memory.inner.clear();
         memory.inner.resize_with(capacity as usize, || None);
-        memory.min_max_key = None;
+        memory.desired_capacity = capacity;
         memory
     }
 
@@ -60,30 +66,31 @@ where
         self.inner.len() as u32
     }
 
+    #[cold]
+    fn allocate_capacity(&mut self) {
+        debug_assert!(self.inner.capacity() == 0, "FlatMap should not be allocated yet");
+        self.inner.reserve_exact(self.desired_capacity as usize);
+        self.inner.resize_with(self.desired_capacity as usize, || None);
+    }
+
     #[inline]
     pub fn insert(&mut self, key: u32, value: T) {
+        if self.inner.capacity() == 0 {
+            self.allocate_capacity();
+        }
         self.inner[key as usize] = Some(value);
-
-        let (min_key, max_key) = self.min_max_key.unwrap_or((key, key));
-        self.min_max_key = Some((min_key.min(key), max_key.max(key)));
     }
 
     #[inline]
     #[allow(dead_code)]
     pub fn clear(&mut self) {
         self.inner.clear();
-        self.min_max_key = None;
     }
 
     #[inline]
     pub fn reset(&mut self) {
-        if let Some((min, max)) = self.min_max_key.take() {
-            self.inner[min as usize..=max as usize].iter_mut().for_each(|value| *value = None);
-        }
-        debug_assert!(
-            self.inner.iter().all(|value| value.is_none()),
-            "FlatMap reset did not clear all values"
-        );
+        self.inner.clear();
+        self.inner.shrink_to_fit();
     }
 }