Merge branch '💥-const-allocator' into 🦆

Author: yvt

src/r3/CHANGELOG.md

@@ -21,6 +21,10 @@ While much of the application-level API has retained its general shape, there ar
 
 TODO
 
+### Fixed
+
+- The hard-coded kernel object count limitation has been removed. This was made possible by the use of growable arrays in the compile-time kernel configurator.
+
 ## [0.1.3] - 2021-10-29
 
 This release only includes changes to the documentation.

src/r3_core/src/kernel/cfg.rs

@@ -1,7 +1,7 @@
 //! Kernel configuration
 use crate::{
     kernel::{hook, interrupt, raw, raw_cfg},
-    utils::{ComptimeVec, Init, PhantomInvariant},
+    utils::{ComptimeVec, ConstAllocator, Frozen, Init, PhantomInvariant},
 };
 
 macro overview_ref() {
@@ -29,37 +29,49 @@ enum CfgSt {
 
 impl<'c, C: raw_cfg::CfgBase> Cfg<'c, C> {
     /// Construct `Cfg`.
-    const fn new(raw: &'c mut C, st: CfgSt) -> Self {
+    const fn new(raw: &'c mut C, allocator: &'c ConstAllocator, st: CfgSt) -> Self {
         Self {
             raw,
             st,
-            startup_hooks: ComptimeVec::new(),
+            startup_hooks: ComptimeVec::new_in(allocator.clone()),
             hunk_pool_len: 0,
             hunk_pool_align: 1,
-            interrupt_lines: ComptimeVec::new(),
-            interrupt_handlers: ComptimeVec::new(),
+            interrupt_lines: ComptimeVec::new_in(allocator.clone()),
+            interrupt_handlers: ComptimeVec::new_in(allocator.clone()),
         }
     }
 
     #[doc(hidden)]
-    pub const fn __internal_new_phase1(raw: &'c mut C, _dummy: &'c mut ()) -> Self {
-        Self::new(raw, CfgSt::Phase1)
+    pub const fn __internal_new_phase1(
+        raw: &'c mut C,
+        allocator: &'c ConstAllocator,
+        _dummy: &'c mut (),
+    ) -> Self {
+        Self::new(raw, allocator, CfgSt::Phase1)
     }
 
     #[doc(hidden)]
-    pub const fn __internal_new_phase2(raw: &'c mut C, _dummy: &'c mut ()) -> Self
+    pub const fn __internal_new_phase2(
+        raw: &'c mut C,
+        allocator: &'c ConstAllocator,
+        _dummy: &'c mut (),
+    ) -> Self
     where
         C::System: CfgPhase1,
     {
-        Self::new(raw, CfgSt::Phase2)
+        Self::new(raw, allocator, CfgSt::Phase2)
     }
 
     #[doc(hidden)]
-    pub const fn __internal_new_phase3(raw: &'c mut C, _dummy: &'c mut ()) -> Self
+    pub const fn __internal_new_phase3(
+        raw: &'c mut C,
+        allocator: &'c ConstAllocator,
+        _dummy: &'c mut (),
+    ) -> Self
     where
         C::System: CfgPhase2,
     {
-        Self::new(raw, CfgSt::Phase3 { interrupts: false })
+        Self::new(raw, allocator, CfgSt::Phase3 { interrupts: false })
     }
 
     /// Mutably borrow the underlying `C`.
@@ -104,10 +116,12 @@ impl<'c, C: raw_cfg::CfgBase> Cfg<'c, C> {
 
         CfgPhase1Data {
             _phantom: Init::INIT,
-            startup_hooks: self.startup_hooks.map(hook::CfgStartupHook::to_attr),
+            startup_hooks: Frozen::leak_slice(
+                &self.startup_hooks.map(hook::CfgStartupHook::to_attr),
+            ),
             hunk_pool_len: self.hunk_pool_len,
             hunk_pool_align: self.hunk_pool_align,
-            interrupt_handlers: self.interrupt_handlers,
+            interrupt_handlers: Frozen::leak_slice(&self.interrupt_handlers),
         }
     }
 
@@ -186,8 +200,8 @@ impl<'c, C: raw_cfg::CfgBase> Cfg<'c, C> {
 
         // Clear these fields to indicate that this method has been called
         // as required
-        self.interrupt_lines = ComptimeVec::new();
-        self.interrupt_handlers = ComptimeVec::new();
+        self.interrupt_lines.clear();
+        self.interrupt_handlers.clear();
     }
 
     /// Finalize `self` for the phase 3 configuration.
@@ -238,10 +252,10 @@ impl<'c, C: raw_cfg::CfgBase> Cfg<'c, C> {
 #[doc = overview_ref!()]
 pub struct CfgPhase1Data<System> {
     _phantom: PhantomInvariant<System>,
-    pub startup_hooks: ComptimeVec<hook::StartupHookAttr>,
+    pub startup_hooks: &'static [Frozen<hook::StartupHookAttr>],
     pub hunk_pool_len: usize,
     pub hunk_pool_align: usize,
-    pub interrupt_handlers: ComptimeVec<interrupt::CfgInterruptHandler>,
+    pub interrupt_handlers: &'static [Frozen<interrupt::CfgInterruptHandler>],
 }
 
 /// The inputs to [`attach_phase2!`].
@@ -504,28 +518,45 @@ where
 
 /// Construct [`Cfg`]`<$RawCfg>` for the phase 3 configuration.
 ///
+///  - `$raw_cfg: &mut impl `[`CfgBase`][]
+///  - `$allocator: &`[`ConstAllocator`][]
+///
 /// `<$RawCfg as `[`CfgBase`][]`>::System` must implement [`CfgPhase2`][].
 ///
 /// [`CfgBase`]: raw_cfg::CfgBase
-pub macro cfg_phase3(let mut $cfg:ident = Cfg::<$RawCfg:ty>::new($raw_cfg:expr)) {
+pub macro cfg_phase3(
+    let mut $cfg:ident = Cfg::<$RawCfg:ty>::new($raw_cfg:expr, $allocator:expr)
+) {
     let mut dummy = ();
-    let mut $cfg = Cfg::<$RawCfg>::__internal_new_phase3(&mut *$raw_cfg, &mut dummy);
+    let mut $cfg = Cfg::<$RawCfg>::__internal_new_phase3(&mut *$raw_cfg, $allocator, &mut dummy);
 }
 
 /// Construct [`Cfg`]`<$RawCfg>` for the phase 2 configuration.
 ///
+///  - `$raw_cfg: &mut impl `[`CfgBase`][]
+///  - `$allocator: &`[`ConstAllocator`][]
+///
 /// `<$RawCfg as `[`CfgBase`][]`>::System` must implement [`CfgPhase1`][].
 ///
 /// [`CfgBase`]: raw_cfg::CfgBase
-pub macro cfg_phase2(let mut $cfg:ident = Cfg::<$RawCfg:ty>::new($raw_cfg:expr)) {
+pub macro cfg_phase2(
+    let mut $cfg:ident = Cfg::<$RawCfg:ty>::new($raw_cfg:expr, $allocator:expr)
+) {
     let mut dummy = ();
-    let mut $cfg = Cfg::<$RawCfg>::__internal_new_phase2(&mut *$raw_cfg, &mut dummy);
+    let mut $cfg = Cfg::<$RawCfg>::__internal_new_phase2(&mut *$raw_cfg, $allocator, &mut dummy);
 }
 
 /// Construct [`Cfg`]`<$RawCfg>` for the phase 1 configuration.
-pub macro cfg_phase1(let mut $cfg:ident = Cfg::<$RawCfg:ty>::new($raw_cfg:expr)) {
+///
+///  - `$raw_cfg: &mut impl `[`CfgBase`][]
+///  - `$allocator: &`[`ConstAllocator`][]
+///
+/// [`CfgBase`]: raw_cfg::CfgBase
+pub macro cfg_phase1(
+    let mut $cfg:ident = Cfg::<$RawCfg:ty>::new($raw_cfg:expr, $allocator:expr)
+) {
     let mut dummy = ();
-    let mut $cfg = Cfg::<$RawCfg>::__internal_new_phase1(&mut *$raw_cfg, &mut dummy);
+    let mut $cfg = Cfg::<$RawCfg>::__internal_new_phase1(&mut *$raw_cfg, $allocator, &mut dummy);
 }
 
 /// Implement [`KernelStatic`] on `$Ty` using the given `$params:
@@ -590,13 +621,15 @@ pub macro attach_phase1($params:expr, impl CfgPhase1<$System:ty> for $Ty:ty $(,)
         array_item_from_fn! {
             const STARTUP_HOOKS: [hook::StartupHookAttr; _] =
                 (0..STATIC_PARAMS.startup_hooks.len())
-                    .map(|i| STATIC_PARAMS.startup_hooks[i]);
+                    .map(|i| STATIC_PARAMS.startup_hooks[i].get());
         }
 
         // Consturct a table of combined second-level interrupt handlers
-        const INTERRUPT_HANDLERS: [interrupt::CfgInterruptHandler; {
-            STATIC_PARAMS.interrupt_handlers.len()
-        }] = STATIC_PARAMS.interrupt_handlers.to_array();
+        array_item_from_fn! {
+            const INTERRUPT_HANDLERS: [interrupt::CfgInterruptHandler; _] =
+                (0..STATIC_PARAMS.interrupt_handlers.len())
+                    .map(|i| STATIC_PARAMS.interrupt_handlers[i].get());
+        }
         const NUM_INTERRUPT_HANDLERS: usize = INTERRUPT_HANDLERS.len();
         const NUM_INTERRUPT_LINES: usize =
             interrupt::num_required_interrupt_line_slots(&INTERRUPT_HANDLERS);

src/r3_core/src/lib.rs

@@ -2,16 +2,29 @@
 #![feature(const_fn_trait_bound)]
 #![feature(const_fn_fn_ptr_basics)]
 #![feature(const_fn_floating_point_arithmetic)]
+#![feature(const_maybe_uninit_as_mut_ptr)]
+#![feature(const_ptr_read)]
 #![feature(generic_const_exprs)]
 #![feature(const_ptr_offset)]
 #![feature(const_swap)]
 #![feature(const_slice_first_last)]
+#![feature(const_replace)]
+#![feature(const_intrinsic_copy)]
+#![feature(const_raw_ptr_comparison)]
+#![feature(const_ptr_offset_from)]
 #![feature(maybe_uninit_slice)]
+#![feature(const_eval_select)]
 #![feature(const_mut_refs)]
 #![feature(const_slice_from_raw_parts)]
 #![feature(const_option)]
+#![feature(const_option_ext)]
 #![feature(const_trait_impl)]
 #![feature(const_refs_to_cell)]
+#![feature(const_ptr_as_ref)]
+#![feature(const_ptr_write)]
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+#![feature(let_else)]
 #![feature(exhaustive_patterns)] // `let Ok(()) = Ok::<(), !>(())`
 #![feature(decl_macro)]
 #![feature(set_ptr_value)] // `<*const T>::set_ptr_value`