jit.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "serene/jit/jit.h"
 
#include <llvm-c/Core.h>
#include <llvm-c/Error.h>
#include <llvm-c/LLJIT.h>
#include <llvm-c/Support.h>
#include <llvm-c/Target.h>
 
#include <stdio.h>
#include <string.h>
 
#include "serene/rt/context.h"
#include "serene/rt/engine.h"
#include "serene/rt/mm/interface.h"
#include "serene/utils.h"
 
static inline int handle_error(LLVMErrorRef err) {
  // TODO(lxsameer): Use the runtime diagnostic system here.
  char *err_msg = LLVMGetErrorMessage(err);
  UNUSED(fprintf(stderr, "Error: %s\n", err_msg));
  LLVMDisposeErrorMessage(err_msg);
  return 1;
}
 
srn_jit_t *srn_jit_make(srn_mm_t *mm) {
  PANIC_IF_NULL(mm);
  srn_jit_t *jit = srn_mm_immortal_allocate(mm, srn_jit_t);
  PANIC_IF_NULL(jit);
  jit->builder  = nullptr;
  jit->llvm_jit = nullptr;
  return jit;
}
 
int srn_jit_init(srn_jit_t *result) {
  PANIC_IF_NULL(result);
 
  int error = 0;
  // TODO(lxsameer): Check for the target platform and setup the codegen
  // and printer accordingly. Only applies to when we want to
  // link the jit library into the target binary.
 
  // Initialize native target codegen and asm printer.
  LLVMInitializeNativeTarget();
  LLVMInitializeNativeAsmPrinter();
 
  LLVMErrorRef err = nullptr;
  err              = LLVMOrcCreateLLJIT(&result->llvm_jit, result->builder);
  if (err) {
    error = handle_error(err);
    LLVMShutdown();
    return error;
  }
  return 0;
}
 
int srn_jit_shutdown(srn_jit_t *jit) {
  PANIC_IF_NULL(jit);
  // A jit that was made but never initialized has no LLJIT instance to
  // dispose.
  if (jit->llvm_jit == nullptr) {
    return 0;
  }
  LLVMErrorRef err = LLVMOrcDisposeLLJIT(jit->llvm_jit);
  if (err) {
    return handle_error(err);
  }
  return 0;
}
 
srn_error_t *srn_jit_add_module(srn_context_t *ctx, srn_jit_module_t *module) {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(module);
 
  LLVMOrcLLJITRef j = ctx->engine->jit->llvm_jit;
 
  LLVMOrcJITDylibRef jd = LLVMOrcLLJITGetMainJITDylib(j);
  LLVMErrorRef err      = LLVMOrcLLJITAddLLVMIRModule(j, jd, module->tsm);
  srn_error_t *srn_err  = nullptr;
 
  if (err != nullptr) {
    // If adding the ThreadSafeModule fails then we need to clean it up
    // ourselves. If adding it succeeds the JIT will manage the memory.
    // LLVMOrcDisposeThreadSafeModule(module);
 
    // LLVM owns the string message, but we want to own it. The copy has to
    // include the terminator; srn_copy_bytes copies exactly the byte count
    // it is given.
    char *jit_err_msg = LLVMGetErrorMessage(err);
    char *msg         = srn_copy_bytes(ctx, jit_err_msg, strlen(jit_err_msg) + 1, alignof(char));
    srn_err           = srn_errors_make(ctx, FAILED_TO_ADD_MODULE, msg);
    LLVMDisposeErrorMessage(jit_err_msg);
  }
  return srn_err;
}