Add support for libcalls in codegen

These are special function calls that backends can emit for operations
not natively supported by their target processor (e.g., 64-bit divisions
on 32-bit targets or bit-manipulation operations on older x86 CPUs).
They end up being surfaced as their own relocation targets in the final
code blob.

Note that while libcalls are now supported throughout both the rust and
C APIs, nothing actually produces or consumes them at the moment.

Author: nmraz

c-api/include/spidir/codegen.h

@@ -47,6 +47,10 @@ enum spidir_reloc_target_kind {
     /// The relocation refers to an internal function, accessible via the
     /// `target.external` relocation field.
     SPIDIR_RELOC_TARGET_EXTERNAL_FUNCTION,
+    /// The relocation refers to a target-specific library call used to
+    /// implement a certain operation. See individual backend definitions for
+    /// possible values.
+    SPIDIR_RELOC_TARGET_LIBCALL,
     /// The relocation refers to the function's constant pool.
     SPIDIR_RELOC_TARGET_CONSTPOOL,
 };
@@ -56,17 +60,23 @@ enum spidir_reloc_target_kind {
 /// See the `SPIDIR_RELOC_TARGET_` constants for possible values.
 typedef uint8_t spidir_reloc_target_kind_t;
 
+/// Represents the different kinds of library calls a target may emit in the
+/// generated code. See individual backend definitions for possible values.
+typedef uint32_t spidir_libcall_kind_t;
+
 /// Represents a relocation in generated code. Relocations can refer either to
 /// other functions or to the function's constant pool.
 typedef struct spidir_codegen_reloc {
     /// The addend for this relocation.
     /// The exact meaning of this field depends on the target architecture and
     /// the value of the `kind` field.
     int64_t addend;
-    /// The target function of this relocation, if it refers to a function.
+    /// The target function of this relocation, if it refers to a function or
+    /// libcall.
     union {
         spidir_function_t internal;
         spidir_extern_function_t external;
+        spidir_libcall_kind_t libcall;
     } target;
     /// The offset in the generated code to which the relocation applies.
     uint32_t offset;

crates/bindings/src/types.rs

@@ -35,11 +35,14 @@ pub struct ApiValue(pub u32);
 #[repr(C)]
 pub struct ApiPhi(pub u32);
 
+pub type ApiLibcallKind = u32;
+
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub union ApiRelocTarget {
     internal: ApiFunction,
     external: ApiExternFunction,
+    libcall: ApiLibcallKind,
 }
 
 #[derive(Clone, Copy)]
@@ -109,7 +112,8 @@ const SPIDIR_MEM_SIZE_8: u8 = 3;
 
 const SPIDIR_RELOC_TARGET_INTERNAL_FUNCTION: u8 = 0;
 const SPIDIR_RELOC_TARGET_EXTERNAL_FUNCTION: u8 = 1;
-const SPIDIR_RELOC_TARGET_CONSTPOOL: u8 = 2;
+const SPIDIR_RELOC_TARGET_LIBCALL: u8 = 3;
+const SPIDIR_RELOC_TARGET_CONSTPOOL: u8 = 3;
 
 pub unsafe fn value_list_from_api(
     arg_count: usize,
@@ -289,6 +293,10 @@ pub fn reloc_to_api(reloc: &Reloc) -> ApiReloc {
                 external: extern_function_to_api(func),
             },
         ),
+        RelocTarget::LibCall(kind) => (
+            SPIDIR_RELOC_TARGET_LIBCALL,
+            ApiRelocTarget { libcall: kind.0 },
+        ),
         RelocTarget::ConstantPool => (
             SPIDIR_RELOC_TARGET_CONSTPOOL,
             ApiRelocTarget {

crates/codegen-test-tools/src/disasm.rs

@@ -9,7 +9,7 @@ use capstone::{
     },
 };
 use codegen::{
-    code_buffer::{CodeBlob, RelocKind, RelocTarget},
+    code_buffer::{CodeBlob, LibCallKind, RelocKind, RelocTarget},
     target::x64::{RELOC_ABS64, RELOC_PC32},
 };
 use ir::{module::ModuleMetadata, write::quote_ident};
@@ -53,6 +53,7 @@ pub fn disasm_code(
                 RelocTarget::Function(func) => {
                     quote_ident(&module_metadata.resolve_funcref(func).name)
                 }
+                RelocTarget::LibCall(kind) => libcall_name(kind).into(),
                 RelocTarget::ConstantPool => "<CP>".into(),
             };
 
@@ -108,4 +109,8 @@ fn reloc_name(reloc: RelocKind) -> String {
     }
 }
 
+fn libcall_name(libcall: LibCallKind) -> String {
+    format!("libcall:{}", libcall.0)
+}
+
 const CP_CHUNK_SIZE: usize = 8;

crates/codegen-test-tools/src/exec.rs

@@ -193,6 +193,7 @@ fn relocate_buf(
                         )
                     })? as u64
                 }
+                RelocTarget::LibCall(_) => bail!("unknown libcall kind"),
                 RelocTarget::ConstantPool => {
                     buf.as_ptr() as u64
                         + constpool_off as u64

crates/codegen/src/code_buffer.rs

@@ -14,6 +14,9 @@ use crate::constpool::{Constant, ConstantPoolBuilder};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct RelocKind(pub u8);
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LibCallKind(pub u32);
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct RawReloc<T> {
     pub kind: RelocKind,
@@ -25,6 +28,7 @@ pub struct RawReloc<T> {
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub enum BufferRelocTarget {
     Function(FunctionRef),
+    LibCall(LibCallKind),
     Constant(Constant),
 }
 
@@ -33,6 +37,7 @@ type BufferReloc = RawReloc<BufferRelocTarget>;
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub enum RelocTarget {
     Function(FunctionRef),
+    LibCall(LibCallKind),
     ConstantPool,
 }
 
@@ -273,6 +278,12 @@ impl<F: FixupKind> CodeBuffer<F> {
                     target: RelocTarget::Function(func),
                     addend: reloc.addend,
                 },
+                BufferRelocTarget::LibCall(kind) => Reloc {
+                    kind: reloc.kind,
+                    offset: reloc.offset,
+                    target: RelocTarget::LibCall(kind),
+                    addend: reloc.addend,
+                },
                 BufferRelocTarget::Constant(constant) => {
                     let offset = constpool.offsets[constant];
                     Reloc {