From 3d48e8cec7715dbdf974157b01b63c482c4464a4 Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Mon, 5 Feb 2024 13:26:49 +0800
Subject: [PATCH 1/9] Add literal projection test.

---
 cpp/src/gandiva/engine.cc               |  1 +
 cpp/src/gandiva/tests/projector_test.cc | 22 ++++++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index bfce72cefc6..c37e6b273e3 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -562,6 +562,7 @@ void Engine::AddGlobalMappingForFunc(const std::string& name, llvm::Type* ret_ty
 }
 
 arrow::Status Engine::AddGlobalMappings() {
+  ARROW_LOG(INFO) << "Adding global mappings for exported functions";
   ARROW_RETURN_NOT_OK(ExportedFuncsRegistry::AddMappings(this));
   ExternalCFunctions c_funcs(function_registry_);
   return c_funcs.AddMappings(this);
diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc
index 59eeb3d92f1..00f96e744d9 100644
--- a/cpp/src/gandiva/tests/projector_test.cc
+++ b/cpp/src/gandiva/tests/projector_test.cc
@@ -3683,4 +3683,26 @@ TEST_F(TestProjector, TestExtendedCFunctionThatNeedsContext) {
   EXPECT_ARROW_ARRAY_EQUALS(out, outs.at(0));
 }
 
+TEST_F(TestProjector, TestLiteralProjection) {
+  auto in_field = field("in", arrow::int64());
+  auto schema = arrow::schema({in_field});
+  auto out_field = field("out", arrow::int64());
+  auto literal =
+      TreeExprBuilder::MakeExpression(TreeExprBuilder::MakeLiteral(1LL), out_field);
+
+  for (int i = 0; i < 1000; i++) {
+    std::shared_ptr<Projector> projector;
+    ARROW_EXPECT_OK(Projector::Make(schema, {literal}, TestConfiguration(), &projector));
+
+    int num_records = 4;
+    auto array = MakeArrowArrayInt64({1, 2, 3, 4}, {true, true, true, true});
+    auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array});
+    auto out = MakeArrowArrayInt64({1, 1, 1, 1}, {true, true, true, true});
+
+    arrow::ArrayVector outs;
+    ARROW_EXPECT_OK(projector->Evaluate(*in_batch, pool_, &outs));
+    EXPECT_ARROW_ARRAY_EQUALS(out, outs.at(0));
+  }
+}
+
 }  // namespace gandiva

From de081e3b0e6c51a6403277511ef7fec95d11f3df Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Wed, 7 Feb 2024 14:50:53 +0800
Subject: [PATCH 2/9] Re-use mangle instead of re-creating it every time.

---
 cpp/src/gandiva/engine.cc | 19 ++++++++++---------
 cpp/src/gandiva/engine.h  |  2 ++
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index c37e6b273e3..a0565d44254 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -156,10 +156,9 @@ std::string DumpModuleIR(const llvm::Module& module) {
   return ir;
 }
 
-void AddAbsoluteSymbol(llvm::orc::LLJIT& lljit, const std::string& name,
+void AddAbsoluteSymbol(llvm::orc::JITDylib& jit_dylib,
+                       llvm::orc::MangleAndInterner& mangle, const std::string& name,
                        void* function_ptr) {
-  llvm::orc::MangleAndInterner mangle(lljit.getExecutionSession(), lljit.getDataLayout());
-
   // https://github.com/llvm/llvm-project/commit/8b1771bd9f304be39d4dcbdcccedb6d3bcd18200#diff-77984a824d9182e5c67a481740f3bc5da78d5bd4cf6e1716a083ddb30a4a4931
   // LLVM 17 introduced ExecutorSymbolDef and move most of ORC APIs to ExecutorAddr
 #if LLVM_VERSION_MAJOR >= 17
@@ -171,21 +170,21 @@ void AddAbsoluteSymbol(llvm::orc::LLJIT& lljit, const std::string& name,
                                   llvm::JITSymbolFlags::Exported);
 #endif
 
-  auto error = lljit.getMainJITDylib().define(
-      llvm::orc::absoluteSymbols({{mangle(name), symbol}}));
+  auto error = jit_dylib.define(llvm::orc::absoluteSymbols({{mangle(name), symbol}}));
   llvm::cantFail(std::move(error));
 }
 
 // add current process symbol to dylib
 // LLVM >= 18 does this automatically
-void AddProcessSymbol(llvm::orc::LLJIT& lljit) {
+void AddProcessSymbol(llvm::orc::LLJIT& lljit, llvm::orc::MangleAndInterner& mangle) {
   lljit.getMainJITDylib().addGenerator(
       llvm::cantFail(llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
           lljit.getDataLayout().getGlobalPrefix())));
   // the `atexit` symbol cannot be found for ASAN
 #ifdef ADDRESS_SANITIZER
   if (!lljit.lookup("atexit")) {
-    AddAbsoluteSymbol(lljit, "atexit", reinterpret_cast<void*>(atexit));
+    AddAbsoluteSymbol(lljit.getMainJITDylib(), mangle, "atexit",
+                      reinterpret_cast<void*>(atexit));
   }
 #endif
 }
@@ -237,7 +236,6 @@ Result<std::unique_ptr<llvm::orc::LLJIT>> BuildJIT(
   ARROW_ASSIGN_OR_RAISE(auto jit,
                         AsArrowResult(maybe_jit, "Could not create LLJIT instance: "));
 
-  AddProcessSymbol(*jit);
   return jit;
 }
 
@@ -290,6 +288,9 @@ Engine::Engine(const std::shared_ptr<Configuration>& conf,
       function_registry_(conf->function_registry()),
       target_machine_(std::move(target_machine)),
       conf_(conf) {
+  mangle_ = std::make_unique<llvm::orc::MangleAndInterner>(lljit_->getExecutionSession(),
+                                                           lljit_->getDataLayout());
+  AddProcessSymbol(*lljit_, *mangle_);
   // LLVM 10 doesn't like the expr function name to be the same as the module name
   auto module_id = "gdv_module_" + std::to_string(reinterpret_cast<uintptr_t>(this));
   module_ = std::make_unique<llvm::Module>(module_id, *context_);
@@ -558,7 +559,7 @@ void Engine::AddGlobalMappingForFunc(const std::string& name, llvm::Type* ret_ty
                                      const std::vector<llvm::Type*>& args, void* func) {
   auto const prototype = llvm::FunctionType::get(ret_type, args, /*is_var_arg*/ false);
   llvm::Function::Create(prototype, llvm::GlobalValue::ExternalLinkage, name, module());
-  AddAbsoluteSymbol(*lljit_, name, func);
+  AddAbsoluteSymbol(lljit_->getMainJITDylib(), *mangle_, name, func);
 }
 
 arrow::Status Engine::AddGlobalMappings() {
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index 565c3f14250..daa13b3d83b 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -26,6 +26,7 @@
 #include <vector>
 
 #include <llvm/Analysis/TargetTransformInfo.h>
+#include <llvm/ExecutionEngine/Orc/Mangling.h>
 
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
@@ -115,6 +116,7 @@ class GANDIVA_EXPORT Engine {
 
   std::unique_ptr<llvm::LLVMContext> context_;
   std::unique_ptr<llvm::orc::LLJIT> lljit_;
+  std::unique_ptr<llvm::orc::MangleAndInterner> mangle_;
   std::unique_ptr<llvm::IRBuilder<>> ir_builder_;
   std::unique_ptr<llvm::Module> module_;
   LLVMTypes types_;

From 787e215da37c55587af08b7d483e9a6869a9fbde Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Wed, 7 Feb 2024 23:23:59 +0800
Subject: [PATCH 3/9] Avoid adding func mapping if it is not used in the
 expression for better performance.

---
 cpp/src/gandiva/engine.cc          |  8 +++++---
 cpp/src/gandiva/engine.h           |  8 +++++---
 cpp/src/gandiva/expr_decomposer.cc |  1 +
 cpp/src/gandiva/expr_decomposer.h  |  6 ++++++
 cpp/src/gandiva/llvm_generator.cc  | 24 +++++++++++++++++++++---
 cpp/src/gandiva/llvm_generator.h   |  6 +++++-
 6 files changed, 43 insertions(+), 10 deletions(-)

diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index a0565d44254..fe5dd1025dd 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -298,7 +298,8 @@ Engine::Engine(const std::shared_ptr<Configuration>& conf,
 
 Engine::~Engine() {}
 
-Status Engine::Init() {
+Status Engine::Init(std::unordered_set<std::string> function_names) {
+  used_functions_ = std::move(function_names);
   std::call_once(register_exported_funcs_flag, gandiva::RegisterExportedFuncs);
 
   // Add mappings for global functions that can be accessed from LLVM/IR module.
@@ -331,7 +332,6 @@ Result<std::unique_ptr<Engine>> Engine::Make(
   std::unique_ptr<Engine> engine{
       new Engine(conf, std::move(jit), std::move(target_machine), cached)};
 
-  ARROW_RETURN_NOT_OK(engine->Init());
   return engine;
 }
 
@@ -557,13 +557,15 @@ Result<void*> Engine::CompiledFunction(const std::string& function) {
 
 void Engine::AddGlobalMappingForFunc(const std::string& name, llvm::Type* ret_type,
                                      const std::vector<llvm::Type*>& args, void* func) {
+  if (used_functions_.find(name) == used_functions_.end()) {
+    return;
+  }
   auto const prototype = llvm::FunctionType::get(ret_type, args, /*is_var_arg*/ false);
   llvm::Function::Create(prototype, llvm::GlobalValue::ExternalLinkage, name, module());
   AddAbsoluteSymbol(lljit_->getMainJITDylib(), *mangle_, name, func);
 }
 
 arrow::Status Engine::AddGlobalMappings() {
-  ARROW_LOG(INFO) << "Adding global mappings for exported functions";
   ARROW_RETURN_NOT_OK(ExportedFuncsRegistry::AddMappings(this));
   ExternalCFunctions c_funcs(function_registry_);
   return c_funcs.AddMappings(this);
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index daa13b3d83b..5dc3ed9a8d8 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -91,14 +91,15 @@ class GANDIVA_EXPORT Engine {
   /// Load the function IRs that can be accessed in the module.
   Status LoadFunctionIRs();
 
+  /// Post construction init. This _must_ be called after the constructor.
+  /// @param[in] used_functions set of function names that are expected to be used by the engine
+  Status Init(std::unordered_set<std::string> used_functions);
+
  private:
   Engine(const std::shared_ptr<Configuration>& conf,
          std::unique_ptr<llvm::orc::LLJIT> lljit,
          std::unique_ptr<llvm::TargetMachine> target_machine, bool cached);
 
-  // Post construction init. This _must_ be called after the constructor.
-  Status Init();
-
   static void InitOnce();
 
   /// load pre-compiled IR modules from precompiled_bitcode.cc and merge them into
@@ -122,6 +123,7 @@ class GANDIVA_EXPORT Engine {
   LLVMTypes types_;
 
   std::vector<std::string> functions_to_compile_;
+  std::unordered_set<std::string> used_functions_;
 
   bool optimize_ = true;
   bool module_finalized_ = false;
diff --git a/cpp/src/gandiva/expr_decomposer.cc b/cpp/src/gandiva/expr_decomposer.cc
index df8eed5fd63..9fdfe089735 100644
--- a/cpp/src/gandiva/expr_decomposer.cc
+++ b/cpp/src/gandiva/expr_decomposer.cc
@@ -69,6 +69,7 @@ Status ExprDecomposer::Visit(const FunctionNode& in_node) {
   const NativeFunction* native_function = registry_.LookupSignature(signature);
   DCHECK(native_function) << "Missing Signature " << signature.ToString();
 
+  used_functions_.emplace(native_function->pc_name());
   // decompose the children.
   std::vector<ValueValidityPairPtr> args;
   for (auto& child : node.children()) {
diff --git a/cpp/src/gandiva/expr_decomposer.h b/cpp/src/gandiva/expr_decomposer.h
index 90a27744b36..e3de40d62b5 100644
--- a/cpp/src/gandiva/expr_decomposer.h
+++ b/cpp/src/gandiva/expr_decomposer.h
@@ -21,6 +21,7 @@
 #include <memory>
 #include <stack>
 #include <string>
+#include <unordered_set>
 #include <utility>
 
 #include "gandiva/arrow.h"
@@ -49,6 +50,10 @@ class GANDIVA_EXPORT ExprDecomposer : public NodeVisitor {
     return status;
   }
 
+  [[nodiscard]] const std::unordered_set<std::string>& UsedFunctions() const {
+    return used_functions_;
+  }
+
  private:
   ARROW_DISALLOW_COPY_AND_ASSIGN(ExprDecomposer);
 
@@ -125,6 +130,7 @@ class GANDIVA_EXPORT ExprDecomposer : public NodeVisitor {
   Annotator& annotator_;
   std::stack<std::unique_ptr<IfStackEntry>> if_entries_stack_;
   ValueValidityPairPtr result_;
+  std::unordered_set<std::string> used_functions_;
   bool nested_if_else_;
 };
 
diff --git a/cpp/src/gandiva/llvm_generator.cc b/cpp/src/gandiva/llvm_generator.cc
index 62ebab08f4d..5f6993798bb 100644
--- a/cpp/src/gandiva/llvm_generator.cc
+++ b/cpp/src/gandiva/llvm_generator.cc
@@ -66,12 +66,20 @@ Status LLVMGenerator::SetLLVMObjectCache(GandivaObjectCache& object_cache) {
   return engine_->SetLLVMObjectCache(object_cache);
 }
 
-Status LLVMGenerator::Add(const ExpressionPtr expr, const FieldDescriptorPtr output) {
-  int idx = static_cast<int>(compiled_exprs_.size());
+arrow::Result<ValueValidityPairPtr> LLVMGenerator::Decompose(const ExpressionPtr& expr) {
   // decompose the expression to separate out value and validities.
   ExprDecomposer decomposer(*function_registry_, annotator_);
   ValueValidityPairPtr value_validity;
   ARROW_RETURN_NOT_OK(decomposer.Decompose(*expr->root(), &value_validity));
+
+  auto& used_functions = decomposer.UsedFunctions();
+  functions_in_exprs_.insert(used_functions.begin(), used_functions.end());
+  return value_validity;
+}
+
+Status LLVMGenerator::Add(const ExpressionPtr expr, ValueValidityPairPtr value_validity,
+                          const FieldDescriptorPtr output) {
+  int idx = static_cast<int>(compiled_exprs_.size());
   // Generate the IR function for the decomposed expression.
   auto compiled_expr = std::make_unique<CompiledExpr>(value_validity, output);
   std::string fn_name = "expr_" + std::to_string(idx) + "_" +
@@ -92,9 +100,19 @@ Status LLVMGenerator::Add(const ExpressionPtr expr, const FieldDescriptorPtr out
 Status LLVMGenerator::Build(const ExpressionVector& exprs, SelectionVector::Mode mode) {
   selection_vector_mode_ = mode;
 
+  std::vector<ValueValidityPairPtr> expr_value_validities;
   for (auto& expr : exprs) {
+    ARROW_ASSIGN_OR_RAISE(auto value_validity, Decompose(expr));
+    expr_value_validities.push_back(value_validity);
+  }
+
+  ARROW_RETURN_NOT_OK(engine_->Init(std::move(functions_in_exprs_)));
+
+  for (size_t i = 0; i < exprs.size(); ++i) {
+    const auto& expr = exprs[i];
     auto output = annotator_.AddOutputFieldDescriptor(expr->result());
-    ARROW_RETURN_NOT_OK(Add(expr, output));
+    auto value_validity = expr_value_validities[i];
+    ARROW_RETURN_NOT_OK(Add(expr, std::move(value_validity), output));
   }
 
   // Compile and inject into the process' memory the generated function.
diff --git a/cpp/src/gandiva/llvm_generator.h b/cpp/src/gandiva/llvm_generator.h
index 0c532998e8b..9fa5ad35742 100644
--- a/cpp/src/gandiva/llvm_generator.h
+++ b/cpp/src/gandiva/llvm_generator.h
@@ -184,9 +184,12 @@ class GANDIVA_EXPORT LLVMGenerator {
     bool has_arena_allocs_;
   };
 
+  arrow::Result<ValueValidityPairPtr> Decompose(const ExpressionPtr& expr);
+
   // Generate the code for one expression for default mode, with the output of
   // the expression going to 'output'.
-  Status Add(const ExpressionPtr expr, const FieldDescriptorPtr output);
+  Status Add(const ExpressionPtr expr, ValueValidityPairPtr value_validity,
+             const FieldDescriptorPtr output);
 
   /// Generate code to load the vector at specified index in the 'arg_addrs' array.
   llvm::Value* LoadVectorAtIndex(llvm::Value* arg_addrs, llvm::Type* type, int idx,
@@ -263,6 +266,7 @@ class GANDIVA_EXPORT LLVMGenerator {
   // used for debug
   bool enable_ir_traces_;
   std::vector<std::string> trace_strings_;
+  std::unordered_set<std::string> functions_in_exprs_;
 };
 
 }  // namespace gandiva

From 10c85d28a68ed1263c0aa98552552cd3fdfaa6e7 Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Wed, 7 Feb 2024 23:24:54 +0800
Subject: [PATCH 4/9] Avoid loading IR and linking IR into module if all
 functions are C functions.

---
 cpp/src/gandiva/engine.cc | 16 ++++++++++------
 cpp/src/gandiva/engine.h  | 12 +++++++++++-
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index fe5dd1025dd..8a533315587 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -308,7 +308,7 @@ Status Engine::Init(std::unordered_set<std::string> function_names) {
 }
 
 Status Engine::LoadFunctionIRs() {
-  if (!functions_loaded_) {
+  if (!functions_loaded_ && used_functions_.size() > used_c_functions_.size()) {
     ARROW_RETURN_NOT_OK(LoadPreCompiledIR());
     ARROW_RETURN_NOT_OK(DecimalIR::AddFunctions(this));
     ARROW_RETURN_NOT_OK(LoadExternalPreCompiledIR());
@@ -557,12 +557,16 @@ Result<void*> Engine::CompiledFunction(const std::string& function) {
 
 void Engine::AddGlobalMappingForFunc(const std::string& name, llvm::Type* ret_type,
                                      const std::vector<llvm::Type*>& args, void* func) {
-  if (used_functions_.find(name) == used_functions_.end()) {
-    return;
+  // if the function is not used, don't add it to the module for better performance
+  bool is_internal_func = internal_functions_.find(name) != internal_functions_.end();
+  if (is_internal_func || used_functions_.find(name) != used_functions_.end()) {
+    if (!is_internal_func) {
+      used_c_functions_.emplace(name);
+    }
+    auto const prototype = llvm::FunctionType::get(ret_type, args, /*is_var_arg*/ false);
+    llvm::Function::Create(prototype, llvm::GlobalValue::ExternalLinkage, name, module());
+    AddAbsoluteSymbol(lljit_->getMainJITDylib(), *mangle_, name, func);
   }
-  auto const prototype = llvm::FunctionType::get(ret_type, args, /*is_var_arg*/ false);
-  llvm::Function::Create(prototype, llvm::GlobalValue::ExternalLinkage, name, module());
-  AddAbsoluteSymbol(lljit_->getMainJITDylib(), *mangle_, name, func);
 }
 
 arrow::Status Engine::AddGlobalMappings() {
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index 5dc3ed9a8d8..c5219349c7c 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -92,7 +92,8 @@ class GANDIVA_EXPORT Engine {
   Status LoadFunctionIRs();
 
   /// Post construction init. This _must_ be called after the constructor.
-  /// @param[in] used_functions set of function names that are expected to be used by the engine
+  /// @param[in] used_functions set of function names that are expected to be used by the
+  /// engine
   Status Init(std::unordered_set<std::string> used_functions);
 
  private:
@@ -124,6 +125,15 @@ class GANDIVA_EXPORT Engine {
 
   std::vector<std::string> functions_to_compile_;
   std::unordered_set<std::string> used_functions_;
+  std::unordered_set<std::string> used_c_functions_;
+  static inline const std::unordered_set<std::string> internal_functions_ = {
+      "gdv_fn_populate_varlen_vector",
+      "gdv_fn_context_arena_reset",
+      "bitMapGetBit",
+      "bitMapValidityGetBit",
+      "bitMapClearBitIfFalse",
+      "gdv_fn_context_arena_malloc",
+      "gdv_fn_context_set_error_msg"};
 
   bool optimize_ = true;
   bool module_finalized_ = false;

From 200d0266db6fc6ea2b1d4aec040bd2721b1191a0 Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Thu, 8 Feb 2024 14:29:00 +0800
Subject: [PATCH 5/9] Separate bitcode into two parts, one mandatory bitcode
 which will always be loaded, and other part is optional and will be loaded
 when necessary.

---
 cpp/src/gandiva/CMakeLists.txt              |  1 +
 cpp/src/gandiva/engine.cc                   | 35 ++++++++++++++++-----
 cpp/src/gandiva/engine.h                    |  6 ++++
 cpp/src/gandiva/make_precompiled_bitcode.py | 24 ++++++++------
 cpp/src/gandiva/precompiled/CMakeLists.txt  | 33 ++++++++++++-------
 cpp/src/gandiva/precompiled_bitcode.cc.in   |  5 +++
 6 files changed, 74 insertions(+), 30 deletions(-)

diff --git a/cpp/src/gandiva/CMakeLists.txt b/cpp/src/gandiva/CMakeLists.txt
index d773fb5ff58..633bf07294c 100644
--- a/cpp/src/gandiva/CMakeLists.txt
+++ b/cpp/src/gandiva/CMakeLists.txt
@@ -36,6 +36,7 @@ provide_cmake_module(GandivaAddBitcode "Gandiva")
 
 # Set the path where the bitcode file generated, see precompiled/CMakeLists.txt
 set(GANDIVA_PRECOMPILED_BC_PATH "${CMAKE_CURRENT_BINARY_DIR}/irhelpers.bc")
+set(GANDIVA_PRECOMPILED_MANDATORY_BC_PATH "${CMAKE_CURRENT_BINARY_DIR}/mandatory_ir.bc")
 set(GANDIVA_PRECOMPILED_CC_PATH "${CMAKE_CURRENT_BINARY_DIR}/precompiled_bitcode.cc")
 set(GANDIVA_PRECOMPILED_CC_IN_PATH
     "${CMAKE_CURRENT_SOURCE_DIR}/precompiled_bitcode.cc.in")
diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index 8a533315587..520d29a2815 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -115,6 +115,9 @@ namespace gandiva {
 extern const unsigned char kPrecompiledBitcode[];
 extern const size_t kPrecompiledBitcodeSize;
 
+extern const unsigned char kPrecompiledMandatoryBitcode[];
+extern const size_t kPrecompiledMandatoryBitcodeSize;
+
 std::once_flag llvm_init_once_flag;
 static bool llvm_init = false;
 static llvm::StringRef cpu_name;
@@ -308,6 +311,11 @@ Status Engine::Init(std::unordered_set<std::string> function_names) {
 }
 
 Status Engine::LoadFunctionIRs() {
+  if (!mandatory_functions_loaded_) {
+    ARROW_RETURN_NOT_OK(LoadMandatoryPreCompiledIR());
+    mandatory_functions_loaded_ = true;
+  }
+
   if (!functions_loaded_ && used_functions_.size() > used_c_functions_.size()) {
     ARROW_RETURN_NOT_OK(LoadPreCompiledIR());
     ARROW_RETURN_NOT_OK(DecimalIR::AddFunctions(this));
@@ -361,14 +369,11 @@ llvm::Module* Engine::module() {
   return module_.get();
 }
 
-// Handling for pre-compiled IR libraries.
-Status Engine::LoadPreCompiledIR() {
-  auto const bitcode = llvm::StringRef(reinterpret_cast<const char*>(kPrecompiledBitcode),
-                                       kPrecompiledBitcodeSize);
-
+Status LoadIR(const std::string& name, llvm::StringRef bitcode, llvm::Module& module,
+              llvm::LLVMContext& context) {
   /// Read from file into memory buffer.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer_or_error =
-      llvm::MemoryBuffer::getMemBuffer(bitcode, "precompiled", false);
+      llvm::MemoryBuffer::getMemBuffer(bitcode, name, false);
 
   ARROW_RETURN_IF(!buffer_or_error,
                   Status::CodeGenError("Could not load module from IR: ",
@@ -378,13 +383,27 @@ Status Engine::LoadPreCompiledIR() {
 
   /// Parse the IR module.
   llvm::Expected<std::unique_ptr<llvm::Module>> module_or_error =
-      llvm::getOwningLazyBitcodeModule(std::move(buffer), *context());
+      llvm::getOwningLazyBitcodeModule(std::move(buffer), context);
   // NOTE: llvm::handleAllErrors() fails linking with RTTI-disabled LLVM builds
   // (ARROW-5148)
-  ARROW_RETURN_NOT_OK(VerifyAndLinkModule(*module_, std::move(module_or_error)));
+  ARROW_RETURN_NOT_OK(VerifyAndLinkModule(module, std::move(module_or_error)));
   return Status::OK();
 }
 
+// Handling for pre-compiled IR libraries.
+Status Engine::LoadPreCompiledIR() {
+  auto const bitcode = llvm::StringRef(reinterpret_cast<const char*>(kPrecompiledBitcode),
+                                       kPrecompiledBitcodeSize);
+  return LoadIR("precompiled", bitcode, *module_, *context());
+}
+
+Status Engine::LoadMandatoryPreCompiledIR() {
+  auto const bitcode =
+      llvm::StringRef(reinterpret_cast<const char*>(kPrecompiledMandatoryBitcode),
+                      kPrecompiledMandatoryBitcodeSize);
+  return LoadIR("mandatory_precompiled", bitcode, *module_, *context());
+}
+
 static llvm::MemoryBufferRef AsLLVMMemoryBuffer(const arrow::Buffer& arrow_buffer) {
   auto const data = reinterpret_cast<const char*>(arrow_buffer.data());
   auto const size = arrow_buffer.size();
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index c5219349c7c..4dd573bb5f8 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -107,6 +107,10 @@ class GANDIVA_EXPORT Engine {
   /// the main module.
   Status LoadPreCompiledIR();
 
+  /// load mandatory pre-compiled IR modules from precompiled_bitcode.cc and merge them into
+  /// the main module. Mandatory IR includes functions manipulating bitmaps
+  Status LoadMandatoryPreCompiledIR();
+
   // load external pre-compiled bitcodes into module
   Status LoadExternalPreCompiledIR();
 
@@ -130,6 +134,7 @@ class GANDIVA_EXPORT Engine {
       "gdv_fn_populate_varlen_vector",
       "gdv_fn_context_arena_reset",
       "bitMapGetBit",
+      "bitMapSetBit",
       "bitMapValidityGetBit",
       "bitMapClearBitIfFalse",
       "gdv_fn_context_arena_malloc",
@@ -139,6 +144,7 @@ class GANDIVA_EXPORT Engine {
   bool module_finalized_ = false;
   bool cached_;
   bool functions_loaded_ = false;
+  bool mandatory_functions_loaded_ = false;
   std::shared_ptr<FunctionRegistry> function_registry_;
   std::string module_ir_;
   std::unique_ptr<llvm::TargetMachine> target_machine_;
diff --git a/cpp/src/gandiva/make_precompiled_bitcode.py b/cpp/src/gandiva/make_precompiled_bitcode.py
index 97d96f8a878..c515748232a 100644
--- a/cpp/src/gandiva/make_precompiled_bitcode.py
+++ b/cpp/src/gandiva/make_precompiled_bitcode.py
@@ -19,7 +19,6 @@
 
 import sys
 
-marker = b"<DATA_CHARS>"
 
 def expand(data):
     """
@@ -29,21 +28,26 @@ def expand(data):
     return expanded_data.encode('ascii')
 
 
-def apply_template(template, data):
+def apply_template(template, marker, data):
     if template.count(marker) != 1:
         raise ValueError("Invalid template")
     return template.replace(marker, expand(data))
 
+def read_file(filepath):
+    with open(filepath, "rb") as file:
+        return file.read()
 
 if __name__ == "__main__":
-    if len(sys.argv) != 4:
-        raise ValueError("Usage: {0} <template file> <data file> "
+    if len(sys.argv) != 5:
+        raise ValueError("Usage: {0} <template file> <mandatory data file> <data file> "
                          "<output file>".format(sys.argv[0]))
-    with open(sys.argv[1], "rb") as f:
-        template = f.read()
-    with open(sys.argv[2], "rb") as f:
-        data = f.read()
 
-    expanded_data = apply_template(template, data)
-    with open(sys.argv[3], "wb") as f:
+    template = read_file(sys.argv[1])
+    mandatory_data = read_file(sys.argv[2])
+    data = read_file(sys.argv[3])
+
+    expanded_data = apply_template(template, b"<MANDATORY_DATA_CHARS>", mandatory_data)
+    expanded_data = apply_template(expanded_data, b"<DATA_CHARS>", data)
+
+    with open(sys.argv[4], "wb") as f:
         f.write(expanded_data)
diff --git a/cpp/src/gandiva/precompiled/CMakeLists.txt b/cpp/src/gandiva/precompiled/CMakeLists.txt
index e62a8e3d4a3..fab7b40b1a8 100644
--- a/cpp/src/gandiva/precompiled/CMakeLists.txt
+++ b/cpp/src/gandiva/precompiled/CMakeLists.txt
@@ -15,9 +15,23 @@
 # specific language governing permissions and limitations
 # under the License.
 
+function(generate_and_link_bitcode src_files bitcode_output_path)
+  set(local_precompiled_bc_files) 
+  foreach(SOURCE ${src_files})
+    gandiva_add_bitcode(${SOURCE}) 
+    get_filename_component(SOURCE_BASE ${SOURCE} NAME_WE)
+    list(APPEND local_precompiled_bc_files ${CMAKE_CURRENT_BINARY_DIR}/${SOURCE_BASE}.bc)
+  endforeach()
+
+# link all of the bitcode files into a single bitcode file.
+  add_custom_command(OUTPUT ${bitcode_output_path}
+                     COMMAND ${LLVM_LINK_EXECUTABLE} -o ${bitcode_output_path}
+                             ${local_precompiled_bc_files}
+                     DEPENDS ${local_precompiled_bc_files})
+endfunction()
+
 set(PRECOMPILED_SRCS
     arithmetic_ops.cc
-    bitmap.cc
     decimal_ops.cc
     decimal_wrapper.cc
     extended_math_ops.cc
@@ -27,29 +41,24 @@ set(PRECOMPILED_SRCS
     time.cc
     timestamp_arithmetic.cc
     ../../arrow/util/basic_decimal.cc)
-set(GANDIVA_PRECOMPILED_BC_FILES)
-foreach(SOURCE ${PRECOMPILED_SRCS})
-  gandiva_add_bitcode(${SOURCE})
-  get_filename_component(SOURCE_BASE ${SOURCE} NAME_WE)
-  list(APPEND GANDIVA_PRECOMPILED_BC_FILES ${CMAKE_CURRENT_BINARY_DIR}/${SOURCE_BASE}.bc)
-endforeach()
+generate_and_link_bitcode("${PRECOMPILED_SRCS}" ${GANDIVA_PRECOMPILED_BC_PATH})
 
-# link all of the bitcode files into a single bitcode file.
-add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_BC_PATH}
-                   COMMAND ${LLVM_LINK_EXECUTABLE} -o ${GANDIVA_PRECOMPILED_BC_PATH}
-                           ${GANDIVA_PRECOMPILED_BC_FILES}
-                   DEPENDS ${GANDIVA_PRECOMPILED_BC_FILES})
+set(MANDATORY_SRCS bitmap.cc)
+generate_and_link_bitcode("${MANDATORY_SRCS}" ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH})
 
 # turn the bitcode file into a C++ static data variable.
 add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_CC_PATH}
                    COMMAND ${PYTHON_EXECUTABLE}
                            "${CMAKE_CURRENT_SOURCE_DIR}/../make_precompiled_bitcode.py"
                            ${GANDIVA_PRECOMPILED_CC_IN_PATH}
+                           ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH} 
                            ${GANDIVA_PRECOMPILED_BC_PATH} ${GANDIVA_PRECOMPILED_CC_PATH}
                    DEPENDS ${GANDIVA_PRECOMPILED_CC_IN_PATH}
+                           ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH} 
                            ${GANDIVA_PRECOMPILED_BC_PATH})
 
 add_custom_target(precompiled ALL DEPENDS ${GANDIVA_PRECOMPILED_BC_PATH}
+                                          ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH} 
                                           ${GANDIVA_PRECOMPILED_CC_PATH})
 
 # testing
diff --git a/cpp/src/gandiva/precompiled_bitcode.cc.in b/cpp/src/gandiva/precompiled_bitcode.cc.in
index 9c382961d25..4005bfb8f17 100644
--- a/cpp/src/gandiva/precompiled_bitcode.cc.in
+++ b/cpp/src/gandiva/precompiled_bitcode.cc.in
@@ -21,6 +21,11 @@ namespace gandiva {
 
 // Content of precompiled bitcode file.
 extern const unsigned char kPrecompiledBitcode[] = { <DATA_CHARS> };
+
+extern const unsigned char kPrecompiledMandatoryBitcode[] = { <MANDATORY_DATA_CHARS> };
+
 extern const size_t kPrecompiledBitcodeSize = sizeof(kPrecompiledBitcode);
 
+extern const size_t kPrecompiledMandatoryBitcodeSize = sizeof(kPrecompiledMandatoryBitcode);
+
 } // namespace gandiva

From ab138b2ed4856a7143941219160d65f9e5b1932d Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Thu, 8 Feb 2024 17:10:56 +0800
Subject: [PATCH 6/9] Avoid adding global mappings if code is cached.

---
 cpp/src/gandiva/engine.cc | 38 +++++++++++++++++++-------------------
 cpp/src/gandiva/engine.h  |  7 ++++---
 2 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index 520d29a2815..082afd00245 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -135,8 +135,8 @@ arrow::Result<T> AsArrowResult(llvm::Expected<T>& expected,
 
 Result<llvm::orc::JITTargetMachineBuilder> MakeTargetMachineBuilder(
     const Configuration& conf) {
-  llvm::orc::JITTargetMachineBuilder jtmb(
-      (llvm::Triple(llvm::sys::getDefaultTargetTriple())));
+  static auto default_target_triple = llvm::sys::getDefaultTargetTriple();
+  llvm::orc::JITTargetMachineBuilder jtmb((llvm::Triple(default_target_triple)));
   if (conf.target_host_cpu()) {
     jtmb.setCPU(cpu_name.str());
     jtmb.addFeatures(cpu_attrs);
@@ -213,6 +213,7 @@ Status UseJITLinkIfEnabled(llvm::orc::LLJITBuilder& jit_builder) {
 
 Result<std::unique_ptr<llvm::orc::LLJIT>> BuildJIT(
     llvm::orc::JITTargetMachineBuilder jtmb,
+    std::unique_ptr<llvm::TargetMachine> target_machine,
     std::optional<std::reference_wrapper<GandivaObjectCache>>& object_cache) {
   llvm::orc::LLJITBuilder jit_builder;
 
@@ -223,22 +224,17 @@ Result<std::unique_ptr<llvm::orc::LLJIT>> BuildJIT(
   jit_builder.setJITTargetMachineBuilder(std::move(jtmb));
   if (object_cache.has_value()) {
     jit_builder.setCompileFunctionCreator(
-        [&object_cache](llvm::orc::JITTargetMachineBuilder JTMB)
+        [&object_cache, &target_machine](llvm::orc::JITTargetMachineBuilder JTMB)
             -> llvm::Expected<std::unique_ptr<llvm::orc::IRCompileLayer::IRCompiler>> {
-          auto target_machine = JTMB.createTargetMachine();
-          if (!target_machine) {
-            return target_machine.takeError();
-          }
           // after compilation, the object code will be stored into the given object
           // cache
           return std::make_unique<llvm::orc::TMOwningSimpleCompiler>(
-              std::move(*target_machine), &object_cache.value().get());
+              std::move(target_machine), &object_cache.value().get());
         });
   }
   auto maybe_jit = jit_builder.create();
   ARROW_ASSIGN_OR_RAISE(auto jit,
                         AsArrowResult(maybe_jit, "Could not create LLJIT instance: "));
-
   return jit;
 }
 
@@ -281,7 +277,7 @@ void Engine::InitOnce() {
 
 Engine::Engine(const std::shared_ptr<Configuration>& conf,
                std::unique_ptr<llvm::orc::LLJIT> lljit,
-               std::unique_ptr<llvm::TargetMachine> target_machine, bool cached)
+               llvm::TargetIRAnalysis target_ir_analysis, bool cached)
     : context_(std::make_unique<llvm::LLVMContext>()),
       lljit_(std::move(lljit)),
       ir_builder_(std::make_unique<llvm::IRBuilder<>>(*context_)),
@@ -289,7 +285,7 @@ Engine::Engine(const std::shared_ptr<Configuration>& conf,
       optimize_(conf->optimize()),
       cached_(cached),
       function_registry_(conf->function_registry()),
-      target_machine_(std::move(target_machine)),
+      target_ir_analysis_(std::move(target_ir_analysis)),
       conf_(conf) {
   mangle_ = std::make_unique<llvm::orc::MangleAndInterner>(lljit_->getExecutionSession(),
                                                            lljit_->getDataLayout());
@@ -332,13 +328,15 @@ Result<std::unique_ptr<Engine>> Engine::Make(
   std::call_once(llvm_init_once_flag, InitOnce);
 
   ARROW_ASSIGN_OR_RAISE(auto jtmb, MakeTargetMachineBuilder(*conf));
-  ARROW_ASSIGN_OR_RAISE(auto jit, BuildJIT(jtmb, object_cache));
   auto maybe_tm = jtmb.createTargetMachine();
   ARROW_ASSIGN_OR_RAISE(auto target_machine,
                         AsArrowResult(maybe_tm, "Could not create target machine: "));
+  auto target_ir_analysis = target_machine->getTargetIRAnalysis();
+  ARROW_ASSIGN_OR_RAISE(auto jit,
+                        BuildJIT(jtmb, std::move(target_machine), object_cache));
 
   std::unique_ptr<Engine> engine{
-      new Engine(conf, std::move(jit), std::move(target_machine), cached)};
+      new Engine(conf, std::move(jit), std::move(target_ir_analysis), cached)};
 
   return engine;
 }
@@ -521,12 +519,11 @@ Status Engine::FinalizeModule() {
     ARROW_RETURN_NOT_OK(RemoveUnusedFunctions());
 
     if (optimize_) {
-      auto target_analysis = target_machine_->getTargetIRAnalysis();
 // misc passes to allow for inlining, vectorization, ..
 #if LLVM_VERSION_MAJOR >= 14
-      OptimizeModuleWithNewPassManager(*module_, std::move(target_analysis));
+      OptimizeModuleWithNewPassManager(*module_, std::move(target_ir_analysis_));
 #else
-      OptimizeModuleWithLegacyPassManager(*module_, std::move(target_analysis));
+      OptimizeModuleWithLegacyPassManager(*module_, std::move(target_ir_analysis_));
 #endif
     }
 
@@ -589,9 +586,12 @@ void Engine::AddGlobalMappingForFunc(const std::string& name, llvm::Type* ret_ty
 }
 
 arrow::Status Engine::AddGlobalMappings() {
-  ARROW_RETURN_NOT_OK(ExportedFuncsRegistry::AddMappings(this));
-  ExternalCFunctions c_funcs(function_registry_);
-  return c_funcs.AddMappings(this);
+  if (!cached_) {
+    ARROW_RETURN_NOT_OK(ExportedFuncsRegistry::AddMappings(this));
+    ExternalCFunctions c_funcs(function_registry_);
+    return c_funcs.AddMappings(this);
+  }
+  return Status::OK();
 }
 
 const std::string& Engine::ir() {
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index 4dd573bb5f8..49b2aec52a3 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -99,7 +99,7 @@ class GANDIVA_EXPORT Engine {
  private:
   Engine(const std::shared_ptr<Configuration>& conf,
          std::unique_ptr<llvm::orc::LLJIT> lljit,
-         std::unique_ptr<llvm::TargetMachine> target_machine, bool cached);
+         llvm::TargetIRAnalysis target_is_analysis, bool cached);
 
   static void InitOnce();
 
@@ -107,8 +107,8 @@ class GANDIVA_EXPORT Engine {
   /// the main module.
   Status LoadPreCompiledIR();
 
-  /// load mandatory pre-compiled IR modules from precompiled_bitcode.cc and merge them into
-  /// the main module. Mandatory IR includes functions manipulating bitmaps
+  /// load mandatory pre-compiled IR modules from precompiled_bitcode.cc and merge them
+  /// into the main module. Mandatory IR includes functions manipulating bitmaps
   Status LoadMandatoryPreCompiledIR();
 
   // load external pre-compiled bitcodes into module
@@ -148,6 +148,7 @@ class GANDIVA_EXPORT Engine {
   std::shared_ptr<FunctionRegistry> function_registry_;
   std::string module_ir_;
   std::unique_ptr<llvm::TargetMachine> target_machine_;
+  llvm::TargetIRAnalysis target_ir_analysis_;
   const std::shared_ptr<Configuration> conf_;
 };
 

From 63f5a2466164a3940ae093901082f88339730929 Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Sun, 11 Feb 2024 12:57:06 +0800
Subject: [PATCH 7/9] Add more benchmark tests to verify gandiva expression
 compilation performance.

---
 cpp/src/gandiva/engine.cc                  |  3 +-
 cpp/src/gandiva/engine.h                   | 15 ++++-
 cpp/src/gandiva/expr_decomposer_test.cc    | 32 +++++++++
 cpp/src/gandiva/precompiled/CMakeLists.txt | 15 +++--
 cpp/src/gandiva/tests/micro_benchmarks.cc  | 77 +++++++++++++++++++++-
 cpp/src/gandiva/tests/projector_test.cc    | 35 +++++++++-
 6 files changed, 162 insertions(+), 15 deletions(-)

diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index 082afd00245..fe082ba672b 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -312,7 +312,8 @@ Status Engine::LoadFunctionIRs() {
     mandatory_functions_loaded_ = true;
   }
 
-  if (!functions_loaded_ && used_functions_.size() > used_c_functions_.size()) {
+  bool is_ir_function_used = used_functions_.size() > used_c_functions_.size();
+  if (!functions_loaded_ && is_ir_function_used) {
     ARROW_RETURN_NOT_OK(LoadPreCompiledIR());
     ARROW_RETURN_NOT_OK(DecimalIR::AddFunctions(this));
     ARROW_RETURN_NOT_OK(LoadExternalPreCompiledIR());
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index 49b2aec52a3..cc4365577ee 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -130,15 +130,26 @@ class GANDIVA_EXPORT Engine {
   std::vector<std::string> functions_to_compile_;
   std::unordered_set<std::string> used_functions_;
   std::unordered_set<std::string> used_c_functions_;
+
+  // all internally used C stub functions and IR function names
   static inline const std::unordered_set<std::string> internal_functions_ = {
+      // internal C stub functions
+      "gdv_fn_context_arena_malloc",
+      "gdv_fn_context_set_error_msg",
       "gdv_fn_populate_varlen_vector",
       "gdv_fn_context_arena_reset",
+      "gdv_fn_in_expr_lookup_int32",
+      "gdv_fn_in_expr_lookup_int64",
+      "gdv_fn_in_expr_lookup_float",
+      "gdv_fn_in_expr_lookup_double",
+      "gdv_fn_in_expr_lookup_decimal",
+      "gdv_fn_in_expr_lookup_utf8",
+      // internal IR functions
       "bitMapGetBit",
       "bitMapSetBit",
       "bitMapValidityGetBit",
       "bitMapClearBitIfFalse",
-      "gdv_fn_context_arena_malloc",
-      "gdv_fn_context_set_error_msg"};
+  };
 
   bool optimize_ = true;
   bool module_finalized_ = false;
diff --git a/cpp/src/gandiva/expr_decomposer_test.cc b/cpp/src/gandiva/expr_decomposer_test.cc
index 194c13bc82c..b954aee7ab9 100644
--- a/cpp/src/gandiva/expr_decomposer_test.cc
+++ b/cpp/src/gandiva/expr_decomposer_test.cc
@@ -19,11 +19,13 @@
 
 #include <gtest/gtest.h>
 
+#include "arrow/testing/gtest_util.h"
 #include "gandiva/annotator.h"
 #include "gandiva/dex.h"
 #include "gandiva/function_registry.h"
 #include "gandiva/gandiva_aliases.h"
 #include "gandiva/node.h"
+#include "gandiva/tree_expr_builder.h"
 
 namespace gandiva {
 
@@ -405,4 +407,34 @@ TEST_F(TestExprDecomposer, TestComplexIfCondition) {
   EXPECT_TRUE(decomposer.if_entries_stack_.empty());
 }
 
+TEST_F(TestExprDecomposer, TestGetUsedFunctionsInExpr) {
+  Annotator annotator;
+  ExprDecomposer decomposer(*registry_, annotator);
+  auto field0 = field("f0", int32());
+  auto f0 = std::make_shared<FieldNode>(field0);
+  auto is_not_null_func = TreeExprBuilder::MakeFunction("isnotnull", {f0}, boolean());
+  ValueValidityPairPtr value_validity;
+  ASSERT_OK(decomposer.Decompose(*is_not_null_func, &value_validity));
+  auto used_functions = decomposer.UsedFunctions();
+  ASSERT_EQ(used_functions.size(), 1);
+  ASSERT_EQ(used_functions.find("isnotnull_int32") != used_functions.end(), true);
+}
+
+TEST_F(TestExprDecomposer, TestGetMultipleUsedFunctionsInExpr) {
+  Annotator annotator;
+  ExprDecomposer decomposer(*registry_, annotator);
+  auto field0 = field("f0", int32());
+  auto field1 = field("f1", int32());
+  auto f0 = std::make_shared<FieldNode>(field0);
+  auto f1 = std::make_shared<FieldNode>(field1);
+  auto add_func = TreeExprBuilder::MakeFunction("add", {f0, f1}, int32());
+  auto is_not_null_func =
+      TreeExprBuilder::MakeFunction("isnotnull", {add_func}, boolean());
+  ValueValidityPairPtr value_validity;
+  ASSERT_OK(decomposer.Decompose(*is_not_null_func, &value_validity));
+  auto used_functions = decomposer.UsedFunctions();
+  ASSERT_EQ(used_functions.size(), 2);
+  ASSERT_EQ(used_functions.find("add_int32_int32") != used_functions.end(), true);
+  ASSERT_EQ(used_functions.find("isnotnull_int32") != used_functions.end(), true);
+}
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/precompiled/CMakeLists.txt b/cpp/src/gandiva/precompiled/CMakeLists.txt
index fab7b40b1a8..9a498dfecaa 100644
--- a/cpp/src/gandiva/precompiled/CMakeLists.txt
+++ b/cpp/src/gandiva/precompiled/CMakeLists.txt
@@ -16,14 +16,14 @@
 # under the License.
 
 function(generate_and_link_bitcode src_files bitcode_output_path)
-  set(local_precompiled_bc_files) 
+  set(local_precompiled_bc_files)
   foreach(SOURCE ${src_files})
-    gandiva_add_bitcode(${SOURCE}) 
+    gandiva_add_bitcode(${SOURCE})
     get_filename_component(SOURCE_BASE ${SOURCE} NAME_WE)
     list(APPEND local_precompiled_bc_files ${CMAKE_CURRENT_BINARY_DIR}/${SOURCE_BASE}.bc)
   endforeach()
 
-# link all of the bitcode files into a single bitcode file.
+  # link all of the bitcode files into a single bitcode file.
   add_custom_command(OUTPUT ${bitcode_output_path}
                      COMMAND ${LLVM_LINK_EXECUTABLE} -o ${bitcode_output_path}
                              ${local_precompiled_bc_files}
@@ -43,7 +43,8 @@ set(PRECOMPILED_SRCS
     ../../arrow/util/basic_decimal.cc)
 generate_and_link_bitcode("${PRECOMPILED_SRCS}" ${GANDIVA_PRECOMPILED_BC_PATH})
 
-set(MANDATORY_SRCS bitmap.cc)
+set(MANDATORY_SRCS
+    bitmap.cc)
 generate_and_link_bitcode("${MANDATORY_SRCS}" ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH})
 
 # turn the bitcode file into a C++ static data variable.
@@ -51,14 +52,14 @@ add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_CC_PATH}
                    COMMAND ${PYTHON_EXECUTABLE}
                            "${CMAKE_CURRENT_SOURCE_DIR}/../make_precompiled_bitcode.py"
                            ${GANDIVA_PRECOMPILED_CC_IN_PATH}
-                           ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH} 
+                           ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH}
                            ${GANDIVA_PRECOMPILED_BC_PATH} ${GANDIVA_PRECOMPILED_CC_PATH}
                    DEPENDS ${GANDIVA_PRECOMPILED_CC_IN_PATH}
-                           ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH} 
+                           ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH}
                            ${GANDIVA_PRECOMPILED_BC_PATH})
 
 add_custom_target(precompiled ALL DEPENDS ${GANDIVA_PRECOMPILED_BC_PATH}
-                                          ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH} 
+                                          ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH}
                                           ${GANDIVA_PRECOMPILED_CC_PATH})
 
 # testing
diff --git a/cpp/src/gandiva/tests/micro_benchmarks.cc b/cpp/src/gandiva/tests/micro_benchmarks.cc
index 450e691323c..856cc192ed4 100644
--- a/cpp/src/gandiva/tests/micro_benchmarks.cc
+++ b/cpp/src/gandiva/tests/micro_benchmarks.cc
@@ -421,13 +421,14 @@ static void DoDecimalAdd2(benchmark::State& state, int32_t precision, int32_t sc
   ASSERT_OK(status);
 }
 
-static void TimedTestExprCompilation(benchmark::State& state) {
+static void TimedTestExprCompilation(benchmark::State& state, bool use_cache) {
   int64_t iteration = 0;
   for (auto _ : state) {
     // schema for input fields
     auto field0 = field("f0", int64());
     auto field1 = field("f1", int64());
-    auto literal = TreeExprBuilder::MakeLiteral(iteration);
+    int64_t literal_value = use_cache ? 1LL : iteration;
+    auto literal = TreeExprBuilder::MakeLiteral(literal_value);
     auto schema = arrow::schema({field0, field1});
 
     // output field
@@ -450,6 +451,47 @@ static void TimedTestExprCompilation(benchmark::State& state) {
   }
 }
 
+static void TimedTestNonBitcodeExprCompilation(benchmark::State& state, bool use_cache) {
+  int32_t iteration = 0;
+  for (auto _ : state) {
+    // schema for input fields
+    int64_t literal_value = use_cache ? 1LL : iteration;
+    auto seed = TreeExprBuilder::MakeLiteral(literal_value);
+    auto schema = arrow::schema({});
+
+    // output field
+    auto field_random = field("c1", float64());
+
+    // seed is different for each iteration so that cache won't be hit
+    auto random_func = TreeExprBuilder::MakeFunction("random", {seed}, float64());
+
+    auto expr_0 = TreeExprBuilder::MakeExpression(random_func, field_random);
+
+    std::shared_ptr<Projector> projector;
+    ASSERT_OK(Projector::Make(schema, {expr_0}, TestConfiguration(), &projector));
+
+    ++iteration;
+  }
+}
+
+static void TimedTestLiteralExprCompilation(benchmark::State& state, bool use_cache) {
+  int64_t iteration = 0;
+  for (auto _ : state) {
+    auto in_field = field("in", arrow::int64());
+    auto schema = arrow::schema({in_field});
+    auto out_field = field("out", arrow::int64());
+
+    int64_t literal_value = use_cache ? 1LL : iteration;
+    auto literal = TreeExprBuilder::MakeExpression(
+        TreeExprBuilder::MakeLiteral(literal_value), out_field);
+
+    std::shared_ptr<Projector> projector;
+    ARROW_EXPECT_OK(Projector::Make(schema, {literal}, TestConfiguration(), &projector));
+  }
+
+  ++iteration;
+}
+
 static void DecimalAdd2Fast(benchmark::State& state) {
   // use lesser precision to test the fast-path
   DoDecimalAdd2(state, DecimalTypeUtil::kMaxPrecision - 6, 18);
@@ -490,7 +532,36 @@ static void DecimalAdd3Large(benchmark::State& state) {
   DoDecimalAdd3(state, DecimalTypeUtil::kMaxPrecision, 18, true);
 }
 
-BENCHMARK(TimedTestExprCompilation)->Unit(benchmark::kMicrosecond);
+static void TimedTestExprCompilationNoCache(benchmark::State& state) {
+  TimedTestExprCompilation(state, false);
+}
+
+static void TimedTestExprCompilationWithCache(benchmark::State& state) {
+  TimedTestExprCompilation(state, true);
+}
+
+static void TimedTestNonBitcodeExprCompilationNoCache(benchmark::State& state) {
+  TimedTestNonBitcodeExprCompilation(state, false);
+}
+
+static void TimedTestNonBitcodeExprCompilationWithCache(benchmark::State& state) {
+  TimedTestNonBitcodeExprCompilation(state, true);
+}
+
+static void TimedTestLiteralExprCompilationNoCache(benchmark::State& state) {
+  TimedTestLiteralExprCompilation(state, false);
+}
+
+static void TimedTestLiteralExprCompilationWithCache(benchmark::State& state) {
+  TimedTestLiteralExprCompilation(state, true);
+}
+
+BENCHMARK(TimedTestExprCompilationNoCache)->Unit(benchmark::kMicrosecond);
+BENCHMARK(TimedTestExprCompilationWithCache)->Unit(benchmark::kMicrosecond);
+BENCHMARK(TimedTestNonBitcodeExprCompilationNoCache)->Unit(benchmark::kMicrosecond);
+BENCHMARK(TimedTestNonBitcodeExprCompilationWithCache)->Unit(benchmark::kMicrosecond);
+BENCHMARK(TimedTestLiteralExprCompilationNoCache)->Unit(benchmark::kMicrosecond);
+BENCHMARK(TimedTestLiteralExprCompilationWithCache)->Unit(benchmark::kMicrosecond);
 BENCHMARK(TimedTestAdd3)->Unit(benchmark::kMicrosecond);
 BENCHMARK(TimedTestBigNested)->Unit(benchmark::kMicrosecond);
 BENCHMARK(TimedTestExtractYear)->Unit(benchmark::kMicrosecond);
diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc
index 00f96e744d9..80add0f5a9b 100644
--- a/cpp/src/gandiva/tests/projector_test.cc
+++ b/cpp/src/gandiva/tests/projector_test.cc
@@ -3687,8 +3687,9 @@ TEST_F(TestProjector, TestLiteralProjection) {
   auto in_field = field("in", arrow::int64());
   auto schema = arrow::schema({in_field});
   auto out_field = field("out", arrow::int64());
-  auto literal =
-      TreeExprBuilder::MakeExpression(TreeExprBuilder::MakeLiteral(1LL), out_field);
+  int64_t literal_value = 1LL;
+  auto literal = TreeExprBuilder::MakeExpression(
+      TreeExprBuilder::MakeLiteral(literal_value), out_field);
 
   for (int i = 0; i < 1000; i++) {
     std::shared_ptr<Projector> projector;
@@ -3705,4 +3706,34 @@ TEST_F(TestProjector, TestLiteralProjection) {
   }
 }
 
+TEST_F(TestProjector, TestInExprProjection) {
+  auto field_in = field("in", int64());
+  auto schema = arrow::schema({field_in});
+
+  // output fields
+  auto field_result = field("res", boolean());
+
+  auto node_in = TreeExprBuilder::MakeField(field_in);
+
+  std::unordered_set<int64_t> values;
+  for (int64_t i = 1; i <= 8; i++) {
+    values.insert(i);
+  }
+  auto in_expr = TreeExprBuilder::MakeInExpressionInt64(node_in, values);
+  auto expr = TreeExprBuilder::MakeExpression(in_expr, field_result);
+
+  // Build a projector for the expressions.
+  std::shared_ptr<Projector> projector;
+  ASSERT_OK(Projector::Make(schema, {expr}, TestConfiguration(), &projector));
+
+  int num_records = 4;
+  auto array = MakeArrowArrayInt64({0, 4, 8, 16}, {true, true, true, true});
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array});
+  auto out = MakeArrowArrayBool({false, true, true, false}, {true, true, true, true});
+
+  arrow::ArrayVector outs;
+  ARROW_EXPECT_OK(projector->Evaluate(*in_batch, pool_, &outs));
+  EXPECT_ARROW_ARRAY_EQUALS(out, outs.at(0));
+}
+
 }  // namespace gandiva

From c04f4074b9cf560090c00d8e12460ecc7e73f67c Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Sun, 11 Feb 2024 23:17:47 +0800
Subject: [PATCH 8/9] Make Gandiva engine to always accept object cache so that
 target machine can be moved into TMOwningSimplerCompiler, and this avoids the
 crash during optimization (TargetIRAnalysis for some reason requires its
 TargetMachine to be alive).

---
 cpp/src/gandiva/engine.cc                  | 48 ++++++++++++++--------
 cpp/src/gandiva/engine.h                   | 15 ++++---
 cpp/src/gandiva/llvm_generator.cc          |  9 ++--
 cpp/src/gandiva/llvm_generator_test.cc     | 13 ++++++
 cpp/src/gandiva/precompiled/CMakeLists.txt | 10 ++---
 cpp/src/gandiva/tests/projector_test.cc    | 24 +++++------
 6 files changed, 77 insertions(+), 42 deletions(-)

diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index fe082ba672b..f9f588f14e7 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -214,7 +214,7 @@ Status UseJITLinkIfEnabled(llvm::orc::LLJITBuilder& jit_builder) {
 Result<std::unique_ptr<llvm::orc::LLJIT>> BuildJIT(
     llvm::orc::JITTargetMachineBuilder jtmb,
     std::unique_ptr<llvm::TargetMachine> target_machine,
-    std::optional<std::reference_wrapper<GandivaObjectCache>>& object_cache) {
+    llvm::ObjectCache* object_cache) {
   llvm::orc::LLJITBuilder jit_builder;
 
 #ifdef JIT_LINK_SUPPORTED
@@ -222,24 +222,21 @@ Result<std::unique_ptr<llvm::orc::LLJIT>> BuildJIT(
 #endif
 
   jit_builder.setJITTargetMachineBuilder(std::move(jtmb));
-  if (object_cache.has_value()) {
-    jit_builder.setCompileFunctionCreator(
-        [&object_cache, &target_machine](llvm::orc::JITTargetMachineBuilder JTMB)
-            -> llvm::Expected<std::unique_ptr<llvm::orc::IRCompileLayer::IRCompiler>> {
-          // after compilation, the object code will be stored into the given object
-          // cache
-          return std::make_unique<llvm::orc::TMOwningSimpleCompiler>(
-              std::move(target_machine), &object_cache.value().get());
-        });
-  }
+  jit_builder.setCompileFunctionCreator(
+      [&object_cache, &target_machine](llvm::orc::JITTargetMachineBuilder JTMB)
+          -> llvm::Expected<std::unique_ptr<llvm::orc::IRCompileLayer::IRCompiler>> {
+        // after compilation, the object code will be stored into the given object
+        // cache
+        return std::make_unique<llvm::orc::TMOwningSimpleCompiler>(
+            std::move(target_machine), object_cache);
+      });
   auto maybe_jit = jit_builder.create();
   ARROW_ASSIGN_OR_RAISE(auto jit,
                         AsArrowResult(maybe_jit, "Could not create LLJIT instance: "));
   return jit;
 }
 
-Status Engine::SetLLVMObjectCache(GandivaObjectCache& object_cache) {
-  auto cached_buffer = object_cache.getObject(nullptr);
+Status Engine::SetCachedObjectCode(std::unique_ptr<llvm::MemoryBuffer> cached_buffer) {
   if (cached_buffer) {
     auto error = lljit_->addObjectFile(std::move(cached_buffer));
     if (error) {
@@ -322,10 +319,29 @@ Status Engine::LoadFunctionIRs() {
   return Status::OK();
 }
 
+class NoOpObjectCache : public llvm::ObjectCache {
+ public:
+  void notifyObjectCompiled(const llvm::Module* M,
+                            llvm::MemoryBufferRef ObjBuffer) override {}
+
+  std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* M) override {
+    return nullptr;
+  }
+};
+
+llvm::ObjectCache* DefaultObjectCache() {
+  static NoOpObjectCache no_op_object_cache;
+  return &no_op_object_cache;
+}
+
 /// factory method to construct the engine.
-Result<std::unique_ptr<Engine>> Engine::Make(
-    const std::shared_ptr<Configuration>& conf, bool cached,
-    std::optional<std::reference_wrapper<GandivaObjectCache>> object_cache) {
+Result<std::unique_ptr<Engine>> Engine::Make(const std::shared_ptr<Configuration>& conf,
+                                             bool cached,
+                                             llvm::ObjectCache* object_cache) {
+  if (object_cache == nullptr) {
+    object_cache = DefaultObjectCache();
+  }
+
   std::call_once(llvm_init_once_flag, InitOnce);
 
   ARROW_ASSIGN_OR_RAISE(auto jtmb, MakeTargetMachineBuilder(*conf));
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index cc4365577ee..a4bfe1e5594 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -26,7 +26,11 @@
 #include <vector>
 
 #include <llvm/Analysis/TargetTransformInfo.h>
+#if LLVM_VERSION_MAJOR >= 11
 #include <llvm/ExecutionEngine/Orc/Mangling.h>
+#else
+#include <llvm/ExecutionEngine/Orc/Core.h>
+#endif
 
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
@@ -58,12 +62,12 @@ class GANDIVA_EXPORT Engine {
   ///
   /// \param[in] config the engine configuration
   /// \param[in] cached flag to mark if the module is already compiled and cached
-  /// \param[in] object_cache an optional object_cache used for building the module
+  /// \param[in] object_cache an optional object_cache used for building the module, if
+  /// not provided, no caching is done
   /// \return arrow::Result containing the created engine
   static Result<std::unique_ptr<Engine>> Make(
       const std::shared_ptr<Configuration>& config, bool cached,
-      std::optional<std::reference_wrapper<GandivaObjectCache>> object_cache =
-          std::nullopt);
+      llvm::ObjectCache* object_cache = NULLPTR);
 
   /// Add the function to the list of IR functions that need to be compiled.
   /// Compiling only the functions that are used by the module saves time.
@@ -75,8 +79,8 @@ class GANDIVA_EXPORT Engine {
   /// Optimise and compile the module.
   Status FinalizeModule();
 
-  /// Set LLVM ObjectCache.
-  Status SetLLVMObjectCache(GandivaObjectCache& object_cache);
+  /// Set cached LLVM ObjectCode
+  Status SetCachedObjectCode(std::unique_ptr<llvm::MemoryBuffer> cached_buffer);
 
   /// Get the compiled function corresponding to the irfunction.
   Result<void*> CompiledFunction(const std::string& function);
@@ -160,6 +164,7 @@ class GANDIVA_EXPORT Engine {
   std::string module_ir_;
   std::unique_ptr<llvm::TargetMachine> target_machine_;
   llvm::TargetIRAnalysis target_ir_analysis_;
+  std::unique_ptr<llvm::ObjectCache> object_cache_;
   const std::shared_ptr<Configuration> conf_;
 };
 
diff --git a/cpp/src/gandiva/llvm_generator.cc b/cpp/src/gandiva/llvm_generator.cc
index 5f6993798bb..8b15d4db108 100644
--- a/cpp/src/gandiva/llvm_generator.cc
+++ b/cpp/src/gandiva/llvm_generator.cc
@@ -48,8 +48,10 @@ Result<std::unique_ptr<LLVMGenerator>> LLVMGenerator::Make(
   std::unique_ptr<LLVMGenerator> llvm_generator(
       new LLVMGenerator(cached, config->function_registry()));
 
-  ARROW_ASSIGN_OR_RAISE(llvm_generator->engine_,
-                        Engine::Make(config, cached, object_cache));
+  ARROW_ASSIGN_OR_RAISE(
+      llvm_generator->engine_,
+      Engine::Make(config, cached,
+                   object_cache.has_value() ? &object_cache.value().get() : nullptr));
   return llvm_generator;
 }
 
@@ -63,7 +65,8 @@ LLVMGenerator::GetCache() {
 }
 
 Status LLVMGenerator::SetLLVMObjectCache(GandivaObjectCache& object_cache) {
-  return engine_->SetLLVMObjectCache(object_cache);
+  auto cached_buffer = object_cache.getObject(nullptr);
+  return engine_->SetCachedObjectCode(std::move(cached_buffer));
 }
 
 arrow::Result<ValueValidityPairPtr> LLVMGenerator::Decompose(const ExpressionPtr& expr) {
diff --git a/cpp/src/gandiva/llvm_generator_test.cc b/cpp/src/gandiva/llvm_generator_test.cc
index 79654e7b78c..10e60c29240 100644
--- a/cpp/src/gandiva/llvm_generator_test.cc
+++ b/cpp/src/gandiva/llvm_generator_test.cc
@@ -49,6 +49,10 @@ class TestLLVMGenerator : public ::testing::Test {
 
     ASSERT_OK_AND_ASSIGN(auto generator, LLVMGenerator::Make(config, false));
 
+    std::unordered_set<std::string> used_functions;
+    used_functions.insert(function_name);
+    ASSERT_OK(generator->engine_->Init(used_functions));
+
     auto module = generator->module();
     ASSERT_OK(generator->engine_->LoadFunctionIRs());
     EXPECT_NE(module->getFunction(function_name), nullptr);
@@ -59,6 +63,11 @@ class TestLLVMGenerator : public ::testing::Test {
 TEST_F(TestLLVMGenerator, VerifyPCFunctions) {
   ASSERT_OK_AND_ASSIGN(auto generator, LLVMGenerator::Make(TestConfiguration(), false));
 
+  std::unordered_set<std::string> used_functions;
+  for (auto& iter : *registry_) {
+    used_functions.insert(iter.pc_name());
+  }
+  ASSERT_OK(generator->engine_->Init(used_functions));
   llvm::Module* module = generator->module();
   ASSERT_OK(generator->engine_->LoadFunctionIRs());
   for (auto& iter : *registry_) {
@@ -102,6 +111,10 @@ TEST_F(TestLLVMGenerator, TestAdd) {
   // LLJIT is used
   std::string fn_name = "llvm_gen_test_add_expr";
 
+  std::unordered_set<std::string> used_functions{"add_int32_int32"};
+
+  ASSERT_OK(generator->engine_->Init(used_functions));
+
   ASSERT_OK(generator->engine_->LoadFunctionIRs());
   ASSERT_OK(generator->CodeGenExprValue(func_dex, 4, desc_sum, 0, fn_name,
                                         SelectionVector::MODE_NONE));
diff --git a/cpp/src/gandiva/precompiled/CMakeLists.txt b/cpp/src/gandiva/precompiled/CMakeLists.txt
index 9a498dfecaa..e4f754bd5c8 100644
--- a/cpp/src/gandiva/precompiled/CMakeLists.txt
+++ b/cpp/src/gandiva/precompiled/CMakeLists.txt
@@ -43,8 +43,7 @@ set(PRECOMPILED_SRCS
     ../../arrow/util/basic_decimal.cc)
 generate_and_link_bitcode("${PRECOMPILED_SRCS}" ${GANDIVA_PRECOMPILED_BC_PATH})
 
-set(MANDATORY_SRCS
-    bitmap.cc)
+set(MANDATORY_SRCS bitmap.cc)
 generate_and_link_bitcode("${MANDATORY_SRCS}" ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH})
 
 # turn the bitcode file into a C++ static data variable.
@@ -58,9 +57,10 @@ add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_CC_PATH}
                            ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH}
                            ${GANDIVA_PRECOMPILED_BC_PATH})
 
-add_custom_target(precompiled ALL DEPENDS ${GANDIVA_PRECOMPILED_BC_PATH}
-                                          ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH}
-                                          ${GANDIVA_PRECOMPILED_CC_PATH})
+add_custom_target(precompiled ALL
+                  DEPENDS ${GANDIVA_PRECOMPILED_BC_PATH}
+                          ${GANDIVA_PRECOMPILED_MANDATORY_BC_PATH}
+                          ${GANDIVA_PRECOMPILED_CC_PATH})
 
 # testing
 if(ARROW_BUILD_TESTS)
diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc
index 80add0f5a9b..faf567828fc 100644
--- a/cpp/src/gandiva/tests/projector_test.cc
+++ b/cpp/src/gandiva/tests/projector_test.cc
@@ -3691,19 +3691,17 @@ TEST_F(TestProjector, TestLiteralProjection) {
   auto literal = TreeExprBuilder::MakeExpression(
       TreeExprBuilder::MakeLiteral(literal_value), out_field);
 
-  for (int i = 0; i < 1000; i++) {
-    std::shared_ptr<Projector> projector;
-    ARROW_EXPECT_OK(Projector::Make(schema, {literal}, TestConfiguration(), &projector));
-
-    int num_records = 4;
-    auto array = MakeArrowArrayInt64({1, 2, 3, 4}, {true, true, true, true});
-    auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array});
-    auto out = MakeArrowArrayInt64({1, 1, 1, 1}, {true, true, true, true});
-
-    arrow::ArrayVector outs;
-    ARROW_EXPECT_OK(projector->Evaluate(*in_batch, pool_, &outs));
-    EXPECT_ARROW_ARRAY_EQUALS(out, outs.at(0));
-  }
+  std::shared_ptr<Projector> projector;
+  ARROW_EXPECT_OK(Projector::Make(schema, {literal}, TestConfiguration(), &projector));
+
+  int num_records = 4;
+  auto array = MakeArrowArrayInt64({1, 2, 3, 4}, {true, true, true, true});
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array});
+  auto out = MakeArrowArrayInt64({1, 1, 1, 1}, {true, true, true, true});
+
+  arrow::ArrayVector outs;
+  ARROW_EXPECT_OK(projector->Evaluate(*in_batch, pool_, &outs));
+  EXPECT_ARROW_ARRAY_EQUALS(out, outs.at(0));
 }
 
 TEST_F(TestProjector, TestInExprProjection) {

From 292455a0834b56e1fbfd9e496536421cec2045af Mon Sep 17 00:00:00 2001
From: Yue Ni <niyue.com@gmail.com>
Date: Tue, 16 Apr 2024 21:50:16 +0800
Subject: [PATCH 9/9] Add test decimal to string.

---
 cpp/src/gandiva/engine.h                |  1 -
 cpp/src/gandiva/gdv_function_stubs.cc   | 13 -----
 cpp/src/gandiva/tests/projector_test.cc | 68 +++++++++++++++++++++++++
 3 files changed, 68 insertions(+), 14 deletions(-)

diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index a4bfe1e5594..f0319047507 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -164,7 +164,6 @@ class GANDIVA_EXPORT Engine {
   std::string module_ir_;
   std::unique_ptr<llvm::TargetMachine> target_machine_;
   llvm::TargetIRAnalysis target_ir_analysis_;
-  std::unique_ptr<llvm::ObjectCache> object_cache_;
   const std::shared_ptr<Configuration> conf_;
 };
 
diff --git a/cpp/src/gandiva/gdv_function_stubs.cc b/cpp/src/gandiva/gdv_function_stubs.cc
index bcef954a473..34ea1d17aa3 100644
--- a/cpp/src/gandiva/gdv_function_stubs.cc
+++ b/cpp/src/gandiva/gdv_function_stubs.cc
@@ -850,19 +850,6 @@ arrow::Status ExportedStubFunctions::AddMappings(Engine* engine) const {
                                   types->i32_type() /*return_type*/, args,
                                   reinterpret_cast<void*>(gdv_fn_dec_from_string));
 
-  // gdv_fn_dec_to_string
-  args = {
-      types->i64_type(),      // context
-      types->i64_type(),      // int64_t x_high
-      types->i64_type(),      // int64_t x_low
-      types->i32_type(),      // int32_t x_scale
-      types->i64_ptr_type(),  // int64_t* dec_str_len
-  };
-
-  engine->AddGlobalMappingForFunc("gdv_fn_dec_to_string",
-                                  types->i8_ptr_type() /*return_type*/, args,
-                                  reinterpret_cast<void*>(gdv_fn_dec_to_string));
-
   // gdv_fn_in_expr_lookup_int32
   args = {types->i64_type(),  // int64_t in holder ptr
           types->i32_type(),  // int32 value
diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc
index faf567828fc..a512ca681f6 100644
--- a/cpp/src/gandiva/tests/projector_test.cc
+++ b/cpp/src/gandiva/tests/projector_test.cc
@@ -51,6 +51,74 @@ class TestProjector : public ::testing::Test {
   arrow::MemoryPool* pool_;
 };
 
+TEST_F(TestProjector, TestCastDecimalToString) {
+  auto field_decimal = field("field_decimal", arrow::decimal(38, 0));
+  auto field_int64 = field("field_int64", int64());
+  auto schema = arrow::schema({field_decimal, field_int64});
+
+  auto field_utf8 = field("result", arrow::utf8());
+  auto expr0 = TreeExprBuilder::MakeExpression("castVARCHAR",
+                                               {field_decimal, field_int64}, field_utf8);
+  std::shared_ptr<Projector> projector0;
+  ASSERT_OK(Projector::Make(schema, {expr0}, TestConfiguration(), &projector0));
+  EXPECT_FALSE(projector0->GetBuiltFromCache());
+}
+
+TEST_F(TestProjector, TestProjectStubFunctionCache) {
+  auto string_literal = TreeExprBuilder::MakeStringLiteral("abc");
+  auto int32_literal = TreeExprBuilder::MakeLiteral(3);
+  // schema for input fields
+  auto field0 = field("f0", utf8());
+  auto schema = arrow::schema({field0});
+
+  // output fields
+  auto field_res = field("result", utf8());
+
+  // Build expression
+  auto fn_node_0 = TreeExprBuilder::MakeFunction("mask_first_n",
+                                                 {string_literal, int32_literal}, utf8());
+  auto fn_node_1 = TreeExprBuilder::MakeFunction("mask_last_n",
+                                                 {string_literal, int32_literal}, utf8());
+  auto expr_0 = TreeExprBuilder::MakeExpression(fn_node_0, field_res);
+  auto expr_1 = TreeExprBuilder::MakeExpression(fn_node_1, field_res);
+
+  auto configuration = TestConfiguration();
+
+  std::shared_ptr<Projector> projector;
+  auto status = Projector::Make(schema, {expr_0, expr_1}, configuration, &projector);
+  ASSERT_OK(status);
+  EXPECT_FALSE(projector->GetBuiltFromCache());
+
+  // everything is same, should return the same projector.
+  auto schema_same = arrow::schema({field0});
+  std::shared_ptr<Projector> cached_projector;
+  status =
+      Projector::Make(schema_same, {expr_0, expr_1}, configuration, &cached_projector);
+  ASSERT_OK(status);
+  EXPECT_TRUE(cached_projector->GetBuiltFromCache());
+
+  //  // schema is different should return a new projector.
+  //  auto field2 = field("f2", int32());
+  //  auto different_schema = arrow::schema({field0, field1, field2});
+  //  std::shared_ptr<Projector> should_be_new_projector;
+  //  status = Projector::Make(different_schema, {sum_expr, sub_expr}, configuration,
+  //                           &should_be_new_projector);
+  //  ASSERT_OK(status);
+  //  EXPECT_FALSE(should_be_new_projector->GetBuiltFromCache());
+  //
+  //  // expression list is different should return a new projector.
+  //  std::shared_ptr<Projector> should_be_new_projector1;
+  //  status = Projector::Make(schema, {sum_expr}, configuration,
+  //  &should_be_new_projector1); ASSERT_OK(status);
+  //  EXPECT_FALSE(should_be_new_projector1->GetBuiltFromCache());
+  //
+  //  // another instance of the same configuration, should return the same projector.
+  //  status = Projector::Make(schema, {sum_expr, sub_expr}, TestConfiguration(),
+  //                           &cached_projector);
+  //  ASSERT_OK(status);
+  //  EXPECT_TRUE(cached_projector->GetBuiltFromCache());
+}
+
 TEST_F(TestProjector, TestProjectCache) {
   // schema for input fields
   auto field0 = field("f0", int32());