Method SetFunctionPointers

be/src/codegen/llvm-codegen.cc:1497–1539

}

bool LlvmCodeGen::SetFunctionPointers(CodeGenCache* cache,
    const CodeGenCacheKey* cache_key) {
  // Get pointers to all codegen'd functions.
  for (auto& entry : fns_to_jit_compile_) {
    const llvm::StringRef& function_name = entry.first;

    LlvmFunctionWithFnPtrTargets& fn_with_targets = entry.second;
    llvm::Function* function = fn_with_targets.first;
    std::vector<CodegenFnPtrBase*>& jitted_fn_ptrs = fn_with_targets.second;

    void* jitted_function = nullptr;
    if (cache != nullptr) {
      DCHECK(cache_key != nullptr);
      // engine_cache_cached_ is used to keep the life of the object cache
      // in case the object cache is evicted in the global cache.
      DCHECK(engine_cache_cached_ != nullptr);
      // Using the function getFunctionAddress() with a non-existent function name would
      // hit an assertion during the test, could be a bug in llvm 5, need to review after
      // upgrade llvm. But because we already checked the names hashcode for key collision
      // cases, we expect all the functions should be in the cached execution engine.
      jitted_function =
          reinterpret_cast<void*>(execution_engine()->getFunctionAddress(function_name));
      if (jitted_function == nullptr) {
        LOG(WARNING) << "Failed to get a jitted function from cache: "
                     << function_name.data()
                     << " key hash_code=" << cache_key->hash_code();
        cache->IncHitOrMissCount(/*hit*/ false);
        return false;
      }
    } else {
      DCHECK(cache_key == nullptr);
      jitted_function = execution_engine()->getPointerToFunction(function);
      DCHECK(jitted_function != nullptr) << "Failed to jit " << function_name.data();
    }

    DCHECK(jitted_function != nullptr);
    for (CodegenFnPtrBase* jitted_fn_ptr : jitted_fn_ptrs) {
      jitted_fn_ptr->store(jitted_function);
    }
  }

  return true;
}

void LlvmCodeGen::DestroyModule() {
  // Clear all references to LLVM objects owned by the module.