de-rust phase-0: archive Rust LLVM backend to archive/rust-llvm-backend (RESTORE documented); defaults unaffected

archive/rust-llvm-backend/llvm/compiler/codegen/instructions/boxcall/marshal.rs

@@ -0,0 +1,96 @@
+use std::collections::HashMap;
+
+use crate::backend::llvm::compiler::codegen::types;
+use inkwell::{values::BasicValueEnum as BVE, AddressSpace};
+
+use crate::backend::llvm::context::CodegenContext;
+use crate::mir::{function::MirFunction, ValueId};
+
+/// Convert a value to i64 handle/int for plugin invoke (ptr->i64, f64->box->i64)
+pub(super) fn get_i64<'ctx, 'b>(
+    codegen: &CodegenContext<'ctx>,
+    cursor: &mut crate::backend::llvm::compiler::codegen::instructions::builder_cursor::BuilderCursor<'ctx, 'b>,
+    resolver: &mut super::super::Resolver<'ctx>,
+    cur_bid: crate::mir::BasicBlockId,
+    func: &MirFunction,
+    vmap: &HashMap<ValueId, inkwell::values::BasicValueEnum<'ctx>>,
+    vid: ValueId,
+    bb_map: &std::collections::HashMap<
+        crate::mir::BasicBlockId,
+        inkwell::basic_block::BasicBlock<'ctx>,
+    >,
+    preds: &std::collections::HashMap<crate::mir::BasicBlockId, Vec<crate::mir::BasicBlockId>>,
+    block_end_values: &std::collections::HashMap<
+        crate::mir::BasicBlockId,
+        std::collections::HashMap<ValueId, inkwell::values::BasicValueEnum<'ctx>>,
+    >,
+) -> Result<inkwell::values::IntValue<'ctx>, String> {
+    let i64t = codegen.context.i64_type();
+    match func.metadata.value_types.get(&vid) {
+        Some(crate::mir::MirType::Float) => {
+            // Box f64 then use its handle
+            let fv = resolver.resolve_f64(
+                codegen,
+                cursor,
+                cur_bid,
+                vid,
+                bb_map,
+                preds,
+                block_end_values,
+                vmap,
+            )?;
+            let fnty = i64t.fn_type(&[codegen.context.f64_type().into()], false);
+            let callee = codegen
+                .module
+                .get_function("nyash.box.from_f64")
+                .unwrap_or_else(|| {
+                    codegen
+                        .module
+                        .add_function("nyash.box.from_f64", fnty, None)
+                });
+            let call = cursor
+                .emit_instr(cur_bid, |b| {
+                    b.build_call(callee, &[fv.into()], "arg_f64_to_box")
+                })
+                .map_err(|e| e.to_string())?;
+            let rv = call
+                .try_as_basic_value()
+                .left()
+                .ok_or("from_f64 returned void".to_string())?;
+            if let BVE::IntValue(h) = rv {
+                Ok(h)
+            } else {
+                Err("from_f64 ret expected i64".to_string())
+            }
+        }
+        _ => resolver.resolve_i64(
+            codegen,
+            cursor,
+            cur_bid,
+            vid,
+            bb_map,
+            preds,
+            block_end_values,
+            vmap,
+        ),
+    }
+}
+
+/// Classify a value into tag constant i64 (uses types::classify_tag)
+pub(super) fn get_tag_const<'ctx>(
+    codegen: &CodegenContext<'ctx>,
+    func: &MirFunction,
+    vid: ValueId,
+) -> inkwell::values::IntValue<'ctx> {
+    let i64t = codegen.context.i64_type();
+    let tag = match func.metadata.value_types.get(&vid) {
+        Some(crate::mir::MirType::Float) => 5,
+        Some(crate::mir::MirType::String)
+        | Some(crate::mir::MirType::Box(_))
+        | Some(crate::mir::MirType::Array(_))
+        | Some(crate::mir::MirType::Future(_))
+        | Some(crate::mir::MirType::Unknown) => 8,
+        _ => 3,
+    };
+    i64t.const_int(tag as u64, false)
+}