Method compile_kernel_modules_with_stdlib

src/compilation_pipeline.rs:1208–1235

(
        &mut self,
        kernel_modules: &[(&str, &str)],
        stdlib_object: &AssembledOutput,
    )

        mode: TargetMode,
    ) -> Result<Vec<(String, AssembledOutput)>, CompilationError> {
        let mut pipeline = CompilationPipeline::new();
        pipeline.set_target_mode(mode);
        pipeline.set_write_artifacts(false);
        pipeline.set_type_prelude(hll_to_ir::stdlib::get_stdlib_type_prelude());
        if mode == TargetMode::Kernel {
            pipeline.set_string_prefix(Some("__kern_str_".to_owned()));
        }
        let modules = hll_to_ir::stdlib::get_stdlib_modules_for_mode(mode);
        let mut objects = Vec::with_capacity(modules.len());
        for (module_name, source) in &modules {
            // Attribute each module to its real source file so stdlib code the
            // debugger steps through maps back to workspace lines.
            let path = hll_to_ir::stdlib::stdlib_module_source_path(mode, module_name);
            pipeline.set_current_source_path(path);
            objects.extend(pipeline.compile_modules(&[(*module_name, *source)])?);
        }
        for object in &mut objects {
            mark_all_defined_symbols_global(object);
        }
        Ok(modules
            .iter()
            .map(|(name, _)| (*name).to_owned())
            .zip(objects)
            .collect())
    }

    /// Compile the kernel modules reachable from `my_kernel` via the qualified-import closure,
    /// deps first, as per-module objects. Mangling is off: the kernel links flat.
    pub fn compile_kernel_module_objects()
    -> Result<Vec<(String, AssembledOutput)>, CompilationError> {
        let mut pipeline = CompilationPipeline::new();