gaia_assembler/backends/dotnet/

msil.rs

//! IL (Intermediate Language) backend compiler

#[cfg(feature = "clr-assembler")]
use crate::{
    adapters::FunctionMapper,
    config::{GaiaConfig, GaiaSettings},
    instruction::{CmpCondition, CoreInstruction, GaiaInstruction},
    program::{GaiaConstant, GaiaFunction, GaiaModule},
    types::GaiaType,
    Backend, GeneratedFiles,
};
#[cfg(feature = "clr-assembler")]
use clr_assembler::program::*;
#[cfg(feature = "clr-assembler")]
use gaia_types::{
    helpers::{AbiCompatible, ApiCompatible, Architecture, ArtifactType, CompilationTarget},
    GaiaError, Result,
};
#[cfg(feature = "clr-assembler")]
use std::collections::HashMap;

/// IL Backend implementation
#[derive(Default)]
#[cfg(feature = "clr-assembler")]
pub struct ClrBackend {}

#[cfg(feature = "clr-assembler")]
impl ClrBackend {
    /// Generate CLR assembly bytecode with specified settings
    pub fn generate_with_settings(program: &GaiaModule, settings: &GaiaSettings) -> Result<Vec<u8>> {
        let clr_program = convert_to_clr_program(program, Some(settings))?;
        let buffer = std::io::Cursor::new(Vec::new());
        let writer = clr_assembler::formats::dll::writer::DllWriter::new(buffer);
        let result = writer.write(&clr_program);
        if let Some(error) = result.diagnostics.into_iter().next() {
            return Err(error);
        }
        Ok(result.result.expect("Failed to get DLL buffer").into_inner())
    }
}

#[cfg(feature = "clr-assembler")]
impl Backend for ClrBackend {
    fn name(&self) -> &'static str {
        "MSIL"
    }

    fn primary_target(&self) -> CompilationTarget {
        CompilationTarget {
            build: Architecture::CLR,
            host: AbiCompatible::MicrosoftIntermediateLanguage,
            target: ApiCompatible::ClrRuntime(4),
        }
    }

    fn artifact_type(&self) -> ArtifactType {
        ArtifactType::Bytecode
    }

    fn match_score(&self, target: &CompilationTarget) -> f32 {
        match target.build {
            Architecture::CLR => match target.host {
                AbiCompatible::Unknown => 30.0,
                AbiCompatible::MicrosoftIntermediateLanguage => 30.0,
                _ => -100.0,
            },
            _ => -100.0,
        }
    }

    fn generate(&self, program: &GaiaModule, _config: &GaiaConfig) -> Result<GeneratedFiles> {
        let clr_program = convert_to_clr_program(program, Some(&_config.setting))?;
        let mut files = HashMap::new();

        match _config.target.host {
            AbiCompatible::Unknown => {
                let buffer = std::io::Cursor::new(Vec::new());
                let writer = clr_assembler::formats::dll::writer::DllWriter::new(buffer);
                let result = writer.write(&clr_program);
                if let Some(error) = result.diagnostics.into_iter().next() {
                    return Err(error);
                }
                files.insert("main.dll".to_string(), result.result.expect("Failed to get DLL buffer").into_inner());
            }
            AbiCompatible::MicrosoftIntermediateLanguage => {
                let source = clr_assembler::formats::msil::program_to_source(&clr_program);
                files.insert("main.il".to_string(), source.into_bytes());
            }
            _ => Err(GaiaError::invalid_data("Unsupported host ABI for CLR backend"))?,
        }

        Ok(GeneratedFiles { artifact_type: ArtifactType::Bytecode, files, diagnostics: vec![] })
    }
}

#[cfg(feature = "clr-assembler")]
struct IlContext {
    builder: ClrBuilder,
    function_mapper: FunctionMapper,
    #[allow(dead_code)]
    field_types: HashMap<(String, String), GaiaType>,
}

#[cfg(feature = "clr-assembler")]
impl IlContext {
    fn new(name: String) -> Self {
        Self { builder: ClrBuilder::new(name), function_mapper: FunctionMapper::new(), field_types: HashMap::new() }
    }

    fn map_function(&self, raw_name: &str) -> String {
        let il_target = CompilationTarget {
            build: Architecture::CLR,
            host: AbiCompatible::MicrosoftIntermediateLanguage,
            target: ApiCompatible::ClrRuntime(4),
        };
        self.function_mapper.map_function(&il_target, raw_name).unwrap_or(raw_name).to_string()
    }
}

#[cfg(feature = "clr-assembler")]
fn convert_to_clr_program(program: &GaiaModule, settings: Option<&GaiaSettings>) -> Result<ClrProgram> {
    let mut context = IlContext::new(program.name.clone());
    if let Some(s) = settings {
        context.function_mapper = FunctionMapper::from_config(s).unwrap_or_default();
    }

    // Handle imports
    for import in &program.imports {
        context.builder.add_external_assembly(import.library.clone());
    }

    // Compile all structs
    for s in &program.structs {
        context.builder.begin_class(s.name.clone(), None);
        for (name, ty) in &s.fields {
            // TODO: Add fields to builder if needed, for now we just handle methods
            context.field_types.insert((s.name.clone(), name.clone()), ty.clone());
        }
        // ClrBuilder will need more methods to handle fields if they are to be included in ClrProgram
    }

    // Compile all functions
    for function in &program.functions {
        let _is_entry = function.name == "main";
        let ret_type = gaia_type_to_clr_type(&function.signature.return_type);

        context.builder.begin_method(function.name.clone(), ret_type);
        // Note: Set entry point flag if needed. ClrBuilder needs to support this.

        for block in &function.blocks {
            for instruction in &block.instructions {
                compile_instruction(&mut context, instruction)?;
            }

            match &block.terminator {
                crate::program::GaiaTerminator::Return => {
                    context.builder.emit(ClrOpcode::Ret, None);
                }
                crate::program::GaiaTerminator::Call { callee, .. } => {
                    let mapped = context.map_function(callee);
                    context.builder.emit(
                        ClrOpcode::Call,
                        Some(ClrInstructionOperand::Method(
                            mapped,
                            None,
                            vec![],
                            Box::new(ClrTypeReference::Primitive("void".to_string())),
                        )),
                    );
                }
                _ => {} // Handle other terminators
            }
        }
    }

    Ok(context.builder.finish())
}

#[cfg(feature = "clr-assembler")]
fn compile_instruction(context: &mut IlContext, instruction: &GaiaInstruction) -> Result<()> {
    match instruction {
        GaiaInstruction::Core(core) => match core {
            CoreInstruction::PushConstant(constant) => match constant {
                GaiaConstant::I32(v) => context.builder.emit(ClrOpcode::LdcI4, Some(ClrInstructionOperand::Int32(*v))),
                GaiaConstant::String(s) => {
                    context.builder.emit(ClrOpcode::Ldstr, Some(ClrInstructionOperand::String(s.clone())))
                }
                _ => {}
            },
            CoreInstruction::Add(_) => context.builder.emit(ClrOpcode::Add, None),
            CoreInstruction::Sub(_) => context.builder.emit(ClrOpcode::Sub, None),
            CoreInstruction::Mul(_) => context.builder.emit(ClrOpcode::Mul, None),
            CoreInstruction::Div(_) => context.builder.emit(ClrOpcode::Div, None),
            _ => {}
        },
        _ => {}
    }
    Ok(())
}

#[cfg(feature = "clr-assembler")]
fn gaia_type_to_clr_type(t: &GaiaType) -> ClrTypeReference {
    match t {
        GaiaType::I32 => ClrTypeReference::Primitive("int32".to_string()),
        GaiaType::String => ClrTypeReference::Primitive("string".to_string()),
        GaiaType::Void => ClrTypeReference::Primitive("void".to_string()),
        _ => ClrTypeReference::Primitive("object".to_string()),
    }
}