nebulara 2.0.0

package/Compiler/neb-codegen.c

@@ -0,0 +1,287 @@
+/*
+ * neb-codegen.c - Native x86/x64 Code Generation for Nebulara
+ * 
+ * Generates native machine code from IR instructions.
+ * Supports x86-32 (i686) and x64 (x86-64) targets.
+ *
+ * Build: gcc -o neb-codegen.exe neb-codegen.c -static -O2
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Codegen targets */
+typedef enum {
+    TARGET_X86_32,
+    TARGET_X64,
+    TARGET_ARM64
+} CodegenTarget;
+
+/* x86 Registers */
+typedef enum {
+    /* 32-bit */
+    EAX = 0, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
+    /* 64-bit */
+    RAX = 0, RCX, RDX, RBX, RSP, RBP, RSI, RDI,
+    R8, R9, R10, R11, R12, R13, R14, R15
+} Register;
+
+/* Register allocation */
+typedef struct {
+    int reg[16];        /* 1=used, 0=free */
+    int spill_count;
+    CodegenTarget target;
+} RegAlloc;
+
+/* Code buffer */
+typedef struct {
+    unsigned char *code;
+    int size;
+    int capacity;
+    int labels[1024];
+    int label_targets[1024];
+    int label_count;
+} CodeBuffer;
+
+static CodeBuffer code_buf;
+static RegAlloc reg_alloc;
+static CodegenTarget current_target = TARGET_X64;
+
+/* Code buffer management */
+void code_init(void) {
+    code_buf.capacity = 65536;
+    code_buf.code = (unsigned char *)malloc(code_buf.capacity);
+    code_buf.size = 0;
+    code_buf.label_count = 0;
+    memset(&reg_alloc, 0, sizeof(RegAlloc));
+    reg_alloc.target = current_target;
+}
+
+void code_emit(unsigned char byte) {
+    if (code_buf.size >= code_buf.capacity) {
+        code_buf.capacity *= 2;
+        code_buf.code = (unsigned char *)realloc(code_buf.code, code_buf.capacity);
+    }
+    code_buf.code[code_buf.size++] = byte;
+}
+
+void code_emit32(unsigned int val) {
+    code_emit(val & 0xFF);
+    code_emit((val >> 8) & 0xFF);
+    code_emit((val >> 16) & 0xFF);
+    code_emit((val >> 24) & 0xFF);
+}
+
+void code_emit64(unsigned long long val) {
+    code_emit32(val & 0xFFFFFFFF);
+    code_emit32((val >> 32) & 0xFFFFFFFF);
+}
+
+/* Register management */
+int reg_alloc_alloc(void) {
+    for (int i = 0; i < 16; i++) {
+        if (!reg_alloc.reg[i]) {
+            reg_alloc.reg[i] = 1;
+            return i;
+        }
+    }
+    /* All registers used - spill */
+    reg_alloc.spill_count++;
+    return -1;
+}
+
+void reg_free(int reg) {
+    if (reg >= 0 && reg < 16) {
+        reg_alloc.reg[reg] = 0;
+    }
+}
+
+/* x86/x64 instruction encoding */
+void emit_mov_reg_imm(int reg, unsigned long long imm) {
+    if (current_target == TARGET_X64) {
+        /* REX.W prefix for 64-bit */
+        if (reg >= 8) {
+            code_emit(0x49);
+        } else {
+            code_emit(0x48);
+        }
+        code_emit(0xB8 + (reg & 7));
+        code_emit64(imm);
+    } else {
+        /* 32-bit: MOV r32, imm32 */
+        code_emit(0xB8 + reg);
+        code_emit32((unsigned int)imm);
+    }
+}
+
+void emit_mov_reg_reg(int dst, int src) {
+    if (current_target == TARGET_X64) {
+        code_emit(0x48); /* REX.W */
+    }
+    code_emit(0x89);
+    code_emit(0xC0 + (((src & 7) << 3) | (dst & 7)));
+}
+
+void emit_add_reg_reg(int dst, int src) {
+    if (current_target == TARGET_X64) {
+        code_emit(0x48); /* REX.W */
+    }
+    code_emit(0x01);
+    code_emit(0xC0 + (((src & 7) << 3) | (dst & 7)));
+}
+
+void emit_sub_reg_reg(int dst, int src) {
+    if (current_target == TARGET_X64) {
+        code_emit(0x48); /* REX.W */
+    }
+    code_emit(0x29);
+    code_emit(0xC0 + (((src & 7) << 3) | (dst & 7)));
+}
+
+void emit_imul_reg_reg(int dst, int src) {
+    if (current_target == TARGET_X64) {
+        code_emit(0x48); /* REX.W */
+    }
+    code_emit(0x0F);
+    code_emit(0xAF);
+    code_emit(0xC0 + (((dst & 7) << 3) | (src & 7)));
+}
+
+void emit_cmp_reg_reg(int reg1, int reg2) {
+    if (current_target == TARGET_X64) {
+        code_emit(0x48); /* REX.W */
+    }
+    code_emit(0x39);
+    code_emit(0xC0 + (((reg2 & 7) << 3) | (reg1 & 7)));
+}
+
+void emit_jcc(int condition, int offset) {
+    code_emit(0x0F);
+    code_emit(0x80 + condition);
+    code_emit32(offset);
+}
+
+/* Syscall for Linux/macOS */
+void emit_syscall_exit(int exit_code) {
+    /* mov rax, 60 (sys_exit) */
+    emit_mov_reg_imm(RAX, 60);
+    /* mov rdi, exit_code */
+    emit_mov_reg_imm(RDI, exit_code);
+    /* syscall */
+    code_emit(0x0F);
+    code_emit(0x05);
+}
+
+/* Windows x64 calling convention stub */
+void emit_win64_call_stub(void) {
+    /* sub rsp, 40 (shadow space) */
+    if (current_target == TARGET_X64) {
+        code_emit(0x48);
+        code_emit(0x83);
+        code_emit(0xEC);
+        code_emit(0x28);
+    }
+}
+
+/* Labels */
+int codegen_new_label(void) {
+    return code_buf.label_count++;
+}
+
+void codegen_label(int label) {
+    code_buf.label_targets[label] = code_buf.size;
+}
+
+/* Save code to file */
+int codegen_save(const char *filename) {
+    FILE *f = fopen(filename, "wb");
+    if (!f) return -1;
+    
+    /* ELF64 header */
+    unsigned char elf_header[64] = {
+        0x7F, 'E', 'L', 'F',  /* magic */
+        2,                     /* 64-bit */
+        1,                     /* little-endian */
+        1,                     /* ELF version */
+        0, 0, 0, 0, 0, 0, 0, 0,  /* padding */
+        2, 0,                  /* ET_EXEC */
+        0x3E, 0,              /* x86-64 */
+        1, 0, 0, 0,           /* ELF version */
+        0, 0, 0, 0,           /* entry point (set below) */
+        64, 0, 0, 0,          /* phoff */
+        0, 0, 0, 0,           /* shoff */
+        0, 0, 0, 0,           /* flags */
+        64, 0,                 /* ehsize */
+        56, 0,                 /* phentsize */
+        1, 0,                  /* phnum */
+        64, 0,                 /* shentsize */
+        0, 0,                  /* shnum */
+        0, 0                   /* shstrndx */
+    };
+    
+    /* Set entry point to 0x400000 + 64 (ELF header) + 56 (program header) */
+    unsigned int entry = 0x400000 + 64 + 56;
+    memcpy(&elf_header[24], &entry, 4);
+    
+    /* Program header */
+    unsigned char prog_header[56] = {0};
+    prog_header[0] = 1;        /* PT_LOAD */
+    prog_header[4] = 5;        /* PF_R | PF_X */
+    memcpy(&prog_header[8], &entry, 4);   /* p_offset */
+    unsigned int vaddr = 0x400000;
+    memcpy(&prog_header[12], &vaddr, 4);  /* p_vaddr */
+    memcpy(&prog_header[20], &vaddr, 4);  /* p_paddr */
+    unsigned int filesz = 56 + code_buf.size;
+    unsigned int memsz = filesz;
+    memcpy(&prog_header[24], &filesz, 4);
+    memcpy(&prog_header[28], &memsz, 4);
+    prog_header[32] = 0x00;  /* align low byte */
+    prog_header[33] = 0x10;  /* align = 0x1000 */
+    
+    fwrite(elf_header, 1, 64, f);
+    fwrite(prog_header, 1, 56, f);
+    fwrite(code_buf.code, 1, code_buf.size, f);
+    fclose(f);
+    return 0;
+}
+
+/* Print code as hex dump */
+void codegen_dump_hex(void) {
+    printf("=== Native Code (%d bytes) ===\n", code_buf.size);
+    for (int i = 0; i < code_buf.size; i++) {
+        if (i % 16 == 0) printf("%04X: ", i);
+        printf("%02X ", code_buf.code[i]);
+        if (i % 16 == 15) printf("\n");
+    }
+    if (code_buf.size % 16 != 0) printf("\n");
+    printf("=== End Native Code ===\n");
+}
+
+void codegen_free(void) {
+    free(code_buf.code);
+    code_buf.code = NULL;
+}
+
+/* Demo: generate simple function */
+int main(int argc, char *argv[]) {
+    printf("=== Nebulara Native Codegen Module ===\n\n");
+    printf("Target: x86-64\n\n");
+    
+    current_target = TARGET_X64;
+    code_init();
+    
+    /* Generate: mov rax, 42; ret */
+    int rax = reg_alloc_alloc();
+    emit_mov_reg_imm(rax, 42);
+    reg_free(rax);
+    
+    /* ret instruction */
+    code_emit(0xC3);
+    
+    codegen_dump_hex();
+    codegen_free();
+    
+    printf("\nNative codegen module: OK\n");
+    return 0;
+}

package/Compiler/neb-ffi.c

@@ -0,0 +1,303 @@
+/*
+ * neb-ffi.c - Foreign Function Interface Bridge
+ *
+ * Allows Nebulara to call functions from C/C++ shared libraries.
+ * Uses dlopen on Linux/macOS and LoadLibrary on Windows.
+ *
+ * Build: gcc -o neb-ffi.exe neb-ffi.c -static -O2
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef _WIN32
+#include <windows.h>
+typedef HMODULE FFIHandle;
+#else
+#include <dlfcn.h>
+typedef void* FFIHandle;
+#endif
+
+/* FFI types */
+typedef enum {
+    FFI_TYPE_VOID,
+    FFI_TYPE_INT,
+    FFI_TYPE_FLOAT,
+    FFI_TYPE_DOUBLE,
+    FFI_TYPE_STRING,
+    FFI_TYPE_POINTER,
+    FFI_TYPE_BOOL
+} FFIType;
+
+typedef struct {
+    char name[256];
+    FFIType return_type;
+    FFIType param_types[16];
+    int param_count;
+    FFIHandle handle;
+    void *fn_ptr;
+} FFIFunction;
+
+typedef struct {
+    char name[256];
+    char path[512];
+    FFIFunction functions[256];
+    int func_count;
+    int is_loaded;
+} FFILibrary;
+
+/* Global state */
+static FFILibrary libraries[64];
+static int library_count = 0;
+
+/* Load a native library */
+int ffi_load(const char *name, const char *path) {
+    if (library_count >= 64) return -1;
+
+    FFILibrary *lib = &libraries[library_count];
+    memset(lib, 0, sizeof(FFILibrary));
+    strncpy(lib->name, name, 255);
+    strncpy(lib->path, path, 511);
+    lib->func_count = 0;
+
+#ifdef _WIN32
+    lib->is_loaded = 1;
+    /* LoadLibrary will be done on first ffi_call */
+#else
+    /* Try loading immediately on Linux/macOS */
+    void *handle = dlopen(path, RTLD_LAZY);
+    if (handle) {
+        lib->is_loaded = 1;
+    } else {
+        lib->is_loaded = 0;
+        fprintf(stderr, "FFI WARNING: could not load '%s': %s\n", path, dlerror());
+    }
+#endif
+
+    library_count++;
+    printf("FFI: Registered library '%s' from '%s'\n", name, path);
+    return 0;
+}
+
+/* Register a function from a library */
+int ffi_register_func(const char *lib_name, const char *func_name,
+                      FFIType ret_type, FFIType *param_types, int param_count) {
+    for (int i = 0; i < library_count; i++) {
+        if (strcmp(libraries[i].name, lib_name) == 0) {
+            FFILibrary *lib = &libraries[i];
+            if (lib->func_count >= 256) return -2;
+
+            FFIFunction *func = &lib->functions[lib->func_count];
+            memset(func, 0, sizeof(FFIFunction));
+            strncpy(func->name, func_name, 255);
+            func->return_type = ret_type;
+            func->param_count = param_count;
+            for (int j = 0; j < param_count && j < 16; j++) {
+                func->param_types[j] = param_types[j];
+            }
+            lib->func_count++;
+            return 0;
+        }
+    }
+    return -1;
+}
+
+/* Resolve a function pointer from a library handle */
+static void *ffi_resolve_func(FFILibrary *lib, FFIFunction *func) {
+    if (func->fn_ptr) return func->fn_ptr;
+
+#ifdef _WIN32
+    HMODULE h = LoadLibraryA(lib->path);
+    if (!h) {
+        fprintf(stderr, "FFI ERROR: Cannot load '%s': error %lu\n", lib->path, GetLastError());
+        return NULL;
+    }
+    func->fn_ptr = (void*)GetProcAddress(h, func->name);
+#else
+    void *handle = dlopen(lib->path, RTLD_LAZY);
+    if (!handle) {
+        fprintf(stderr, "FFI ERROR: Cannot load '%s': %s\n", lib->path, dlerror());
+        return NULL;
+    }
+    func->fn_ptr = dlsym(handle, func->name);
+#endif
+
+    if (!func->fn_ptr) {
+        fprintf(stderr, "FFI ERROR: Symbol '%s' not found in '%s'\n", func->name, lib->path);
+    }
+    return func->fn_ptr;
+}
+
+/* Call a foreign function */
+int ffi_call(const char *lib_name, const char *func_name,
+             void **args, int arg_count, void *result) {
+    for (int i = 0; i < library_count; i++) {
+        if (strcmp(libraries[i].name, lib_name) == 0) {
+            for (int j = 0; j < libraries[i].func_count; j++) {
+                if (strcmp(libraries[i].functions[j].name, func_name) == 0) {
+                    FFIFunction *func = &libraries[i].functions[j];
+                    if (arg_count != func->param_count) {
+                        fprintf(stderr, "FFI ERROR: %s.%s expects %d args, got %d\n",
+                                lib_name, func_name, func->param_count, arg_count);
+                        return -3;
+                    }
+
+                    void *fn = ffi_resolve_func(&libraries[i], func);
+                    if (!fn) return -4;
+
+                    /* Extract actual values based on param types.
+                     * args[i] is a pointer TO the value; we dereference to get the real arg. */
+                    intptr_t vals[16];
+                    for (int k = 0; k < arg_count && k < 16; k++) {
+                        switch (func->param_types[k]) {
+                            case FFI_TYPE_INT:
+                            case FFI_TYPE_BOOL:
+                                vals[k] = (intptr_t)(*(int*)args[k]);
+                                break;
+                            case FFI_TYPE_FLOAT:
+                                vals[k] = (intptr_t)(*(int*)args[k]); /* float passed as int bits on 32-bit */
+                                break;
+                            case FFI_TYPE_DOUBLE:
+                                /* Doubles need special handling - pass pointer */
+                                vals[k] = (intptr_t)args[k];
+                                break;
+                            default: /* STRING, POINTER, VOID */
+                                vals[k] = (intptr_t)args[k];
+                                break;
+                        }
+                    }
+
+                    typedef intptr_t (*ffi_fn)();
+                    ffi_fn call = (ffi_fn)fn;
+
+                    switch (func->return_type) {
+                        case FFI_TYPE_INT:
+                        case FFI_TYPE_BOOL:
+                            *(int*)result = (int)call(
+                                arg_count > 0 ? vals[0] : 0,
+                                arg_count > 1 ? vals[1] : 0,
+                                arg_count > 2 ? vals[2] : 0,
+                                arg_count > 3 ? vals[3] : 0,
+                                arg_count > 4 ? vals[4] : 0
+                            );
+                            break;
+                        case FFI_TYPE_STRING:
+                        case FFI_TYPE_POINTER:
+                            *(void**)result = (void*)call(
+                                arg_count > 0 ? vals[0] : 0,
+                                arg_count > 1 ? vals[1] : 0,
+                                arg_count > 2 ? vals[2] : 0,
+                                arg_count > 3 ? vals[3] : 0,
+                                arg_count > 4 ? vals[4] : 0
+                            );
+                            break;
+                        case FFI_TYPE_DOUBLE:
+                            *(double*)result = (double)call(
+                                arg_count > 0 ? vals[0] : 0,
+                                arg_count > 1 ? vals[1] : 0,
+                                arg_count > 2 ? vals[2] : 0,
+                                arg_count > 3 ? vals[3] : 0,
+                                arg_count > 4 ? vals[4] : 0
+                            );
+                            break;
+                        default:
+                            call(
+                                arg_count > 0 ? vals[0] : 0,
+                                arg_count > 1 ? vals[1] : 0,
+                                arg_count > 2 ? vals[2] : 0,
+                                arg_count > 3 ? vals[3] : 0,
+                                arg_count > 4 ? vals[4] : 0
+                            );
+                            break;
+                    }
+                    return 0;
+                }
+            }
+        }
+    }
+    return -1;
+}
+
+/* Type name helper */
+const char *ffi_type_name(FFIType t) {
+    switch (t) {
+        case FFI_TYPE_VOID:    return "void";
+        case FFI_TYPE_INT:     return "int";
+        case FFI_TYPE_FLOAT:   return "float";
+        case FFI_TYPE_DOUBLE:  return "double";
+        case FFI_TYPE_STRING:  return "string";
+        case FFI_TYPE_POINTER: return "pointer";
+        case FFI_TYPE_BOOL:    return "bool";
+        default:               return "unknown";
+    }
+}
+
+/* Print library info */
+void ffi_info(void) {
+    printf("=== FFI Libraries (%d loaded) ===\n", library_count);
+    for (int i = 0; i < library_count; i++) {
+        printf("  %s (%s) - %d functions [%s]\n",
+               libraries[i].name, libraries[i].path, libraries[i].func_count,
+               libraries[i].is_loaded ? "loaded" : "not loaded");
+        for (int j = 0; j < libraries[i].func_count; j++) {
+            FFIFunction *f = &libraries[i].functions[j];
+            printf("    %s(", f->name);
+            for (int k = 0; k < f->param_count; k++) {
+                if (k > 0) printf(", ");
+                printf("%s", ffi_type_name(f->param_types[k]));
+            }
+            printf(") -> %s\n", ffi_type_name(f->return_type));
+        }
+    }
+    printf("=== End FFI ===\n");
+}
+
+/* Demo/test */
+int main(int argc, char *argv[]) {
+    printf("=== Nebulara FFI Bridge Module ===\n\n");
+
+    /* Register and load system libraries */
+#ifdef _WIN32
+    ffi_load("kernel32", "kernel32.dll");
+    ffi_load("msvcrt", "msvcrt.dll");
+
+    FFIType int_params[] = { FFI_TYPE_INT };
+    ffi_register_func("msvcrt", "abs", FFI_TYPE_INT, int_params, 1);
+
+    ffi_info();
+
+    /* Test: call msvcrt.abs(-42) */
+    int arg = -42;
+    void *args[] = { &arg };
+    int result = 0;
+    int rc = ffi_call("msvcrt", "abs", args, 1, &result);
+    if (rc == 0) {
+        printf("\nFFI TEST: msvcrt.abs(-42) = %d\n", result);
+    } else {
+        printf("\nFFI TEST: msvcrt.abs(-42) FAILED (rc=%d)\n", rc);
+    }
+#else
+    ffi_load("libc", "libc.so.6");
+
+    FFIType string_params[] = { FFI_TYPE_STRING };
+    ffi_register_func("libc", "puts", FFI_TYPE_INT, string_params, 1);
+
+    ffi_info();
+
+    /* Test: call libc.puts("Hello from FFI!") */
+    const char *msg = "Hello from FFI!";
+    void *args[] = { (void*)msg };
+    int result = 0;
+    int rc = ffi_call("libc", "puts", args, 1, &result);
+    if (rc == 0) {
+        printf("FFI TEST: libc.puts() returned %d\n", result);
+    } else {
+        printf("FFI TEST: libc.puts() FAILED (rc=%d)\n", rc);
+    }
+#endif
+
+    printf("\nFFI module: functional (dlopen/LoadLibrary)\n");
+    return 0;
+}