jit.h File Reference

#include <llvm-c/LLJIT.h>
#include "serene/rt/errors.h"

Include dependency graph for jit.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	srn_jit_module_t
struct	srn_jit_t

Typedefs
typedef struct srn_engine_t	srn_engine_t
typedef struct srn_jit_module_t	srn_jit_module_t
typedef struct srn_jit_t	srn_jit_t

Functions
srn_jit_t *	srn_jit_make (srn_mm_t *mm)
int	srn_jit_init (srn_jit_t *result)
	Creates a jit engine and sets the given result to it.
int	srn_jit_shutdown (srn_jit_t *jit)
srn_error_t *	srn_jit_add_module (srn_context_t *ctx, srn_jit_module_t *module)
	Add a module to the jit compiler.

Typedef Documentation

srn_engine_t

typedef struct srn_engine_t srn_engine_t

Definition at line 25 of file jit.h.

srn_jit_module_t

typedef struct srn_jit_module_t srn_jit_module_t

srn_jit_t

typedef struct srn_jit_t srn_jit_t

Function Documentation

srn_jit_add_module()

srn_error_t * srn_jit_add_module	(	srn_context_t *	ctx,
		srn_jit_module_t *	module )

Add a module to the jit compiler.

Definition at line 88 of file jit.c.

                                                                              {
  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;
}

Here is the call graph for this function:

srn_jit_init()

int srn_jit_init

(

srn_jit_t *

result

)

Creates a jit engine and sets the given result to it.

Definition at line 52 of file jit.c.

                                    {
  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;
}

Here is the call graph for this function:

srn_jit_make()

srn_jit_t * srn_jit_make

(

srn_mm_t *

mm

)

Definition at line 43 of file jit.c.

                                      {
  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;
}

srn_jit_shutdown()

int srn_jit_shutdown

(

srn_jit_t *

jit

)

Definition at line 74 of file jit.c.

                                     {
  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;
}

Here is the call graph for this function: