jit.cpp

Go to the documentation of this file.

/* -*- C++ -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * 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/ExecutionEngine/JITEventListener.h>
#include <llvm/ExecutionEngine/ObjectCache.h>
#include <llvm/ExecutionEngine/Orc/LLJIT.h>
#include <llvm/Support/Error.h>
#include <llvm/Support/TargetSelect.h>
 
#include <memory>
#include <string>
#include <utility>
 
struct srn_object_cache_t : public llvm::ObjectCache {
  /// Cache the given `objBuffer` for the given module `m`. The buffer contains
  /// the combiled objects of the module
  void notifyObjectCompiled(const llvm::Module *m, llvm::MemoryBufferRef objBuffer) override;
 
  // Lookup the cache for the given module `m` or returen a nullptr.
  std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module *m) override;
 
  /// Dump cached object to output file `filename`.
  void dumpToObjectFile(llvm::StringRef filename);
 
private:
  llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> cachedObjects;
};
 
// The JIT engine handle. It is a C++ object owning the ORC session, so it is
// allocated with `new` and freed with `delete` rather than through the arena:
// the LLJIT and the cached strings need their destructors to run. `mm` is
// retained for the memory-manager-backed allocations a later JITLink
// integration will make.
struct srn_jit_t {
  srn_mm_t *mm;
  std::unique_ptr<llvm::orc::LLJIT> jit;
  std::unique_ptr<srn_object_cache_t> cache;
 
  /// GDB notification listener.
  llvm::JITEventListener *gdbListener;
 
  /// Perf notification listener.
  llvm::JITEventListener *perfListener;
 
  llvm::orc::JITTargetMachineBuilder jtmb;
  llvm::DataLayout &data_layout;
  srn_context_t &root_ctx;
 
  llvm::Triple triple;
  srn_jit_config_t config;
};
 
extern "C" {
 
srn_jit_t *srn_jit_create(srn_mm_t *mm, const srn_jit_config_t *config) {
  if (mm == nullptr) {
    return nullptr;
  }
 
  // TODO(lxsameer): long term, we might want to check the binfmt and enable none
  // native targets here as well.
  llvm::InitializeNativeTarget();
  llvm::InitializeNativeTargetAsmPrinter();
 
  auto jit_or_err = llvm::orc::LLJITBuilder().create();
  if (!jit_or_err) {
    llvm::consumeError(jit_or_err.takeError());
    return nullptr;
  }
 
  auto *self        = new srn_jit_t{};
  self->mm          = mm;
  self->jit         = std::move(*jit_or_err);
  self->data_layout = self->jit->getDataLayout().getStringRepresentation();
  self->triple      = self->jit->getTargetTriple();
  self->config      = (config != nullptr)
                        ? *config
                        : srn_jit_config_t{.opt_level = 2, .install_default_pipeline = true};
 
  return self;
}
 
void srn_jit_destroy(srn_jit_t *jit) { delete jit; }
 
const char *srn_jit_data_layout(srn_jit_t *jit) { return jit->data_layout.c_str(); }
 
const char *srn_jit_triple(srn_jit_t *jit) { return jit->triple.c_str(); }
 
srn_error_t *
srn_jit_add_ir(srn_jit_t *, srn_context_t *ctx, const char *, size_t, srn_jit_module_t **) {
  return srn_errors_make(ctx, NOT_IMPLEMENTED, "srn_jit_add_ir is not yet implemented");
}
 
srn_error_t *
srn_jit_add_bitcode(srn_jit_t *, srn_context_t *ctx, const void *, size_t, srn_jit_module_t **) {
  return srn_errors_make(ctx, NOT_IMPLEMENTED, "srn_jit_add_bitcode is not yet implemented");
}
 
srn_error_t *srn_jit_define(srn_jit_t *, srn_context_t *ctx, const char *, void *) {
  return srn_errors_make(ctx, NOT_IMPLEMENTED, "srn_jit_define is not yet implemented");
}
 
srn_error_t *srn_jit_expose_process_symbols(srn_jit_t *, srn_context_t *ctx) {
  return srn_errors_make(
    ctx, NOT_IMPLEMENTED, "srn_jit_expose_process_symbols is not yet implemented"
  );
}
 
srn_error_t *srn_jit_lookup(srn_jit_t *, srn_context_t *ctx, const char *, void **) {
  return srn_errors_make(ctx, NOT_IMPLEMENTED, "srn_jit_lookup is not yet implemented");
}
 
srn_error_t *srn_jit_remove(srn_jit_t *, srn_context_t *ctx, srn_jit_module_t *) {
  return srn_errors_make(ctx, NOT_IMPLEMENTED, "srn_jit_remove is not yet implemented");
}
 
} // extern "C"