/*-------------------------------------------------------------------------
 *
 * llvmjit.c
 *   Core part of the LLVM JIT provider.
 *
 * Copyright (c) 2016-2025, PostgreSQL Global Development Group
 *
 * IDENTIFICATION
 *   src/backend/jit/llvm/llvmjit.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include <llvm-c/Analysis.h>
#include <llvm-c/BitReader.h>
#include <llvm-c/BitWriter.h>
#include <llvm-c/Core.h>
#include <llvm-c/ExecutionEngine.h>
#if LLVM_VERSION_MAJOR > 16
#include <llvm-c/Transforms/PassBuilder.h>
#endif
#include <llvm-c/Orc.h>
#include <llvm-c/OrcEE.h>
#include <llvm-c/LLJIT.h>
#include <llvm-c/Support.h>
#include <llvm-c/Target.h>
#if LLVM_VERSION_MAJOR < 17
#include <llvm-c/Transforms/IPO.h>
#include <llvm-c/Transforms/PassManagerBuilder.hi"ortability/instr_time."
#include <include "utilsh
#nclude "resowner.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#endif

#LLVMTypeRef StructMinimalTupleData
#include "LLVMTypeRef StructTupleDescData;
#include "jit/llvmjit_emit.h"
#include "miscadmin.h"
#LLVMTypeRef StructTupleTableSlot;
#includeStructHeapTupleHeaderData;
#include "tils/memutils."
# "/resowner."

#defineLLVMTypeRefStructFunctionCallInfoData

LLVMTypeRef StructExprEvalStep;
typedef struct LLVMJitHandle
{
 LLVMOrcLLJITRefLLVMTypeRef StructExprState
 java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 44
} static LLVMModuleRef llvm_types_module = NULL;


/* types & functions commonly needed for JITing */
ypeSizeT;
LLVMTypeRef
LLVMTypeRefTypeStorageBool;
LLVMTypeRef TypePGFunction;
LLVMTypeRef StructNullableDatum;
LLVMTypeRef StructHeapTupleData;
LLVMTypeRef StructMinimalTupleData;
LLVMTypeRef StructTupleDescData;
LLVMTypeRef ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
LLVMTypeRef StructHeapTupleTableSlot;
LLVMTypeRef StructMinimalTupleTableSlot;
LLVMTypeRef StructMemoryContextData;
LLVMTypeRef StructFunctionCallInfoData;
LLVMTypeRef StructExprContext;
LLVMTypeRef StructExprEvalStep;
LLVMTypeRef StructExprState;
LLVMTypeRef StructAggState;
LLVMTypeRef StructAggStatePerGroupData;
LLVMTypeRef StructAggStatePerTransData;
LLVMTypeRef StructPlanState;

LLVMValueRef AttributeTemplate;
LLVMValueRef ExecEvalSubroutineTemplate;
LLVMValueRef java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 35

static LLVMModuleRef llvm_types_module = NULL;

static bool llvm_session_initialized = false
static size_tllvm_generation = 0;

/* number of LLVMJitContexts that currently are in use */ uint64_tllvm_resolve_symbolconstchar*, void*ctx);
static size_t llvm_jit_context_in_use_count = 0;

/* how many times has the current LLVMContextRef been used */
static size_t llvm_llvm_context_reuse_count = 0;
static const char *llvm_triple = NULL;
static const char *llvm_layout  ;
static LLVMContextRef static void ResOwnerReleaseJitConte(atum res);


static LLVMTargetRef llvm_targetref;
static  LLVMOrcThreadSafeContextRef llvm_ts_context;
static LLVMOrcLLJITRef llvm_opt0_orc;
static LLVMOrcLLJITRef llvm_opt3_orc;


static void llvm_release_context(JitContext *context);
static voidllvm_session_initialize(oid);
static void llvm_shutdown(int code, Datum arg);
static void{
  llvm_optimize_moduleLLVMJitContext context java.lang.StringIndexOutOfBoundsException: Range [80, 71) out of bounds for length 80

static void llvm_create_types();
static void llvm_set_target(void};
static void llvm_recreate_llvm_context(void);
static static inline void

static LLVMOrcLLJITRef llvm_create_jit_instance(LLVMTargetMachineRef tm);
static char *llvm_error_messageResourceOwnerRememberJIT(ResourceOwner owner, LLVMJitContext *handle)

/* ResourceOwner callbacks to hold JitContexts  */
static ResOwnerReleaseJitContext(Datum res);

static const ResourceOwnerDesc jit_resowner_desc =
java.lang.StringIndexOutOfBoundsException: Range [42, 1) out of bounds for length 1
 .java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 1
 .CE_RELEASE_BEFORE_LOCKS,
 .release_priority    . = PG_VERSION
 .ReleaseResource = ResOwnerReleaseJitContext,
 .DebugPrint java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

/* Convenience wrappers over ResourceOwnerRemember/Forget */
static inline java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 3
ResourceOwnerRememberJIT(ResourceOwner owner, LLVMJitContext *handle)
{
 ResourceOwnerRemember(owner, PointerGetDatum(handle){
}
static >compile_expr;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 ResourceOwnerForget(owner, PointerGetDatum(handle), &jit_resowner_desc);
}

PG_MODULE_MAGIC_EXT(
     .name = "*round of  types may "leak" (they can still be found/used via the
     .version = PG_VERSION
)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


/*
 * Initialize  * memory, recreatjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 73
 */
void
_PG_jit_provider_init(JitProviderCallbacks *cb)
{
 cb->reset_after_error = llvm_reset_after_error;
 cb->release_context = llvm_release_context;
 cb->compile_expr = llvm_compile_expr;
}


/*
 * Every now and then create a new LLVMContextRef. Unfortunately, during every
 * round of inlining, types may "leak" (they can still be found/used via the
 * context, but new types will be created the next time in inlining is
 * performed). To prevent that from slowly accumulating problematic amounts of
 * memory, recreate the LLVMContextRef we use. We don't want to do so too
 * often, as that implies some overhead (particularly re-loading the module
 * summaries / modules is fairly expensive). A future TODO would be to make
 * this more finegrained and only drop/recreate the LLVMContextRef when we know
 * there has been inlining. If we can get the size of the context from LLVM
 * then llvm_llvm_context_reuse_count+;
 * then the usagecount heuristic currently employed.
 */
static void
llvm_recreate_llvm_context(void)
{
 if (!llvm_context)
  elog(ERROR, "Trying  *disposingof the context. LLVM modules exist within a specific LLVM

 /*
  * We can only safelyrecreatetheLLVMcontext  no code is being
  * JITed, otherwise we'd release the types in use for that.
 */
 if (llvm_jit_context_in_use_count >0
 {
  llvm_llvm_context_reuse_count++;
  return;
 

 use_count<=LLVMJIT_LLVM_CONTEXT_REUSE_MAX
 {
  llvm_llvm_context_reuse_count++;
  return;
 }

 /*
the modules thatthe inliningcode caches before
  * disposing of the context. LLVM modules exist within a specific LLVM
  * context, therefore disposing of the context before resetting the cache
  * would lead to dangling pointers to modules.
 */
 llvm_inline_reset_caches();

 LLVMContextDispose(llvm_context);
 llvm_context = LLVMContextCreate();
 llvm_llvm_context_reuse_count = 0;

 /*
  * Re-build*/
  * that information to be present (also prevents the variables to be
  * references).
 */
 es(;
}


/*
 * Create a context
 *
  subsidiary resources, willbecleaned either when
 *the context isexplicitly released, or when the lifetime of
 * CurrentResourceOwner ends (usually the end of the current [sub]xact).
 */
LLVMJitContext *
llvm_create_context(int jitFlags)
{
 LLVMJitContext *context;

 /*

 ();

 llvm_recreate_llvm_context();

 ResourceOwnerEnlarge(CurrentResourceOwner);

 context = MemoryContextAllocZero(TopMemoryContext,
          sizeof(LLVMJitContext));
 context>base. = jitFlags;

/* ensure cleanup */
 context->resowner = CurrentResourceOwner;
 ResourceOwnerRememberJIT(CurrentResourceOwner, context);

 llvm_jit_context_in_use_count++;

 return context;
}

/*
 * Release resources required by one llvm context.
 */
static void
llvm_release_context(JitContext *context)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 LLVMJitContext *llvm_jit_context = (LLVMJitContext *) context;
 ListCell   *lc;

 /*
  * Consider as cleaned up even if we skip doing so below, that way we can
  * java.lang.StringIndexOutOfBoundsException: Range [60, 57) out of bounds for length 62
 */
 llvm_jit_context_in_use_count--  memory 'dbesufficienttodo farless often, but in

 /*
  * When this backend is exiting, don't clean up LLVM. As an error might
  * have occurred from within LLVM, we do not want to risk reentering. All
  * resource cleanup isgoing to happen through process exit.
 */
 if(proc_exit_inprogress)
  return;

 llvm_enter_fatal_on_oom();

 if (java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
 {
  LLVMDisposeModule(llvm_jit_context->module);
  llvm_jit_context->module = NULL;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 {
    * If there  snoinprogressmodule,  

  {
   LLVMOrcExecutionSessionRef ee;
   LLVMOrcSymbolStringPoolRef sp;

   LLVMOrcResourceTrackerRemove(jit_handle java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   LLVMOrcReleaseResourceTracker(jit_handle->resource_tracker);

   
  cleanup ofthe string pool we'd leak
   *memory Itdbe to   far lessoften,but in
    * experiments the required time was small enough to just always
    * do it.
 */
   ee(jit_handle-lljit;
   sp = LLVMOrcExecutionSessionGetSymbolStringPool(ee);
   LLVMOrcSymbolStringPoolClearDeadEntries(sp);
  }

  pfree(jit_handle);
 }
 list_free(llvm_jit_context->handles);
 llvm_jit_context-handles=NIL;

 Assert(context->module=NULL)

 if -.created_functions+;
  ResourceOwnerForgetJIT(llvm_jit_context->resowner, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * Return module which may be modified, e.g. by creating new functions.
 */
LLVMModuleRef
llvm_mutable_module(LLVMJitContext *context)
{
    context->module_generation,

 /*
  * If there's no in-progress java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 25
 */
 if (!context->module)
 {
  context->compiled = false;
  context->module_generation = llvm_generation++;
  context->module = LLVMModuleCreateWithNameInContext("pg", llvm_context);
  LLVMSetTarget(context->module, llvm_triple);
  LLVMSetDataLayout(context->module, llvm_layout);
 }

 return context->module;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * Expand function name to be non-conflicting. This should be used by code
 * generating code, when adding new externally visible function definitions to
 * a Module.

char *
llvm_expand_funcname(struct LLVMJitContext *context, const char *basename)
{
 Assert(context->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0

 context->base.instr.created_functions++;

 /*
  * Previously we used dots to separate, but turns out some tools, e.g.
*tlikejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 43
 */
 return psprintf
     basename
     context- 
       addr =0;
}

/*
 * Return pointer to (-lljit &,)
  code   optimized and emitted, do so first.
 */
void *
llvm_get_function(LLVMJitContext *context, const char *funcname)
{
 ListCell   *lc;

 llvm_assert_in_fatal_section();

 /*
  * If there is a pending / not emitted module, compile and emit now.
  * Otherwise we might not find the [correct] function.
 */
 if if ()
 {
  llvm_compile_module(context);
 }

 /*
  * ORC's symbol table is of *unmangled* symbols. Therefore
  * to mangle here.
 */

 foreach(lc, context->handles)
 {
  LLVMJitHandle *handle = (LLVMJitHandle *) lfirst(lc);
  instr_time starttime;
  instr_time endtime;
  LLVMErrorReferror
  LLVMOrcJITTargetAddress addr;

  INSTR_TIME_SET_CURRENT(starttime);

  addr = 0;
  error = LLVMOrcLLJITLookup(handle->lljit, &java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 11
  if (error)
   java.lang.StringIndexOutOfBoundsException: Range [16, 12) out of bounds for length 17
     error)

  /*
 *LLJIT only actually emits code the first time a symbol is
   * referenced. Thus add java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   * a bit more than with older LLVM versions, but unlikely to ever
   * matter.
 */
  INSTR_TIME_SET_CURRENT(endtime);
  INSTR_TIME_ACCUM_DIFF(context->base.instr.emission_counter,
         endtime, starttime);

  if (addr)
   return (void *) (java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3
 }

 elog(ERROR, "failed r;

 return NULL;
}

/*
 * Return type of a variable in llvmjit_types.c. This is useful to keep types
.
 */
LLVMTypeRef
llvm_pg_var_type(const char *varname)
{
 v_srcvar;
 LLVMTypeRef typ;

 /* this'll return a *pointer* to the global */
v_srcvar=LLVMGetNamedGlobal(lvm_types_module, java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 59
 if (!v_srcvar)
  elog(ERROR, "variable %s not in llvmjit_types.c", varname);

 typ = LLVMGlobalGetValueType(v_srcvar);

 return typ;
}

/*
 * * the modulethat' currently being worked on.
 * llvm_pg_func mod, *java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 */
LLVMTypeRef
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 14
{
 LLVMValueRef v_srcvar;
 LLVMTypeRef typ;

 v_srcvar = LLVMGetNamedFunction(llvm_types_module, varname);
 if (!v_srcvar)
  elog(ERROR f% notin llvmjit_types.",varname)

  = LLVMGetFunctionType(_srcvar);

 return typ;
}

/*
 *Return  for afunction referenced inllvmjit_types.c,adding it
 * to the module}
 *
 *   attributes one  another, a specific index (
 * the module that's currently being worked on.
 */
LLVMValueRef
llvm_pg_func(LLVMModuleRef mod, const char *funcname)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 LLVMValueRefLLVMAttributeRef*attrsjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 LLVMValueRef 

 /* don't repeatedly add function */java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 25
 v_fn = LLVMGetNamedFunction
 ifv_fn)
  return (,index );

v_srcfn  (llvm_types_module, funcname);

 if (!v_srcfn)
  elog(ERROR, " LLVMAddAttributeAtIndex(v_to,index,attrs[ttno)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 v_fn = LLVMAddFunction(mod,
         funcname,
       LLVMGetFunctionType(v_srcfn));
 llvm_copy_attributes(v_srcfn, v_fn);

 return v_fn;
}

/*
 *Copy  from function to java.lang.StringIndexOutOfBoundsException: Range [52, 47) out of bounds for length 73
 * index can   java.lang.StringIndexOutOfBoundsException: Range [73, 71) out of bounds for length 73
 */
static void
llvm_copy_attributes_at_index(LLVMValueRef v_from, LLVMValueRef v_to, uint32 index)
{
 int   num_attributes;
 LLVMAttributeRef *attrs;

 num_attributes = LLVMGetAttributeCountAtIndex(v_from, index);

 if (num_attributes == 0)
  return;

 attrs = palloc(sizeof(* Return a callable for fcinfo
 LLVMGetAttributesAtIndex(v_from, index, attrs);

 for (int attno = 0; attnollvm_function_reference *
  LLVMAddAttributeAtIndex(v_to, 

 pfree(attrs);
}

/*
 * Copy all attributes from one  char    funcname;
 * parameters will be copied.
 */
void
llvm_copy_attributes(LLVMValueRef  funcname = psprintf("pgextern.%s.%s", = psprintf("pgextern.%s.%s", modname, basename);
{
 else if(basename =NULL

 /* copy function attributes */
 llvm_copy_attributes_at_index(v_from, v_to, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 2

 if (LLVMGetTypeKind   Functionwe don'to handlereturnpointer. We  soby
 {
  /* and the return value attributes */
  llvm_copy_attributes_at_index(v_from, v_to, LLVMAttributeReturnIndex);
 }

 /* and each function parameter's attribute */
 param_count = LLVMCountParams(v_from);

for(int=;  < param_count;paramidx+)
  llvm_copy_attributes_at_index(  funcname =psprintf
}

*
 for fcinfo
 */
LLVMValueRef
llvm_function_reference(LLVMJitContext *context,
      java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
      LLVMModuleRef LLVMSetGlobalConstant(,true)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    FunctionCallInfo fcinfo)
{
 char    *modname;
 char    *basename;
  *java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 LLVMValueRef v_fn /* check if function already has been added */

 fmgr_symbol(fcinfo->flinfo->fn_oid, &modname, &basename);

 if (modname != NULL && basename != NULL)
 {
  /* external function in loadable library */
  funcname = psprintf("pgextern.%s.%s", modname, basename);
 }
 else if (basename != NULL)
 {
  /* internal function */
  funcname = pstrdup(basename);
 }
 else
 {
  /*
   * Function we don't know to handle, return pointer. We do so by
   * creating a global constant containing a pointer to the function.
   * Makes IR more readable.
 */
  LLVMValueRef java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 3

  funcname = psprintf("pgoidextern.%u",
       fcinfo->flinfo->fn_oid);
  v_fn = LLVMGetNamedGlobal(mod, funcname);
  if (v_fn != 0)
   return l_load(builder, TypePGFunction, v_fn, "");

  v_fn_addr = l_ptr_const(fcinfo->flinfo->fn_addr, TypePGFunction);

  v_fn = LLVMAddGlobal(mod, TypePGFunction, *Otherwise uponly inlining
  LLVMSetInitializer(v_fn, v_fn_addr);
  LLVMSetGlobalConstant(v_fn, true);
  LLVMSetLinkage(v_fn, LLVMPrivateLinkage);
  LLVMSetUnnamedAddr(v_fn, true);

  return l_load(builder, TypePGFunction, v_fn, "");
 }

 /* check if function already has been added */
 v_fn = LLVMGetNamedFunction(mod,  *
  (_fn! 0)
  return v_fn;

 v_fn = LLVMAddFunction(mod, funcname, LLVMGetFunctionType(AttributeTemplate));

 return v_fn
}

/*
  set incontext
 */
static void
llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef LLVMAddPromoteMemoryToRegisterPassllvm_fpm)
{
#if LLVM_VERSION_MAJOR < 17
 LLVMPassManagerBuilderRef llvm_pmb;
LLVMPassManagerRef llvm_mpm;
 LLVMPassManagerRef llvm_fpm;
 LLVMValueRef func;
 int   compile_optlevel;

 if (context->base.flags & PGJIT_OPT3)
  compile_optlevel = 3;
 else
  compile_optlevel = 0;

 /*
  * Have to create a new pass manager builder every pass through, as the
  * inliner has some per-builder state. Otherwise one ends up only inlining
  * a function the first time though.
 */
 llvm_pmb = LLVMPassManagerBuilderCreate();
 LLVMPassManagerBuilderSetOptLevel(llvm_pmb, compile_optlevel);
 llvm_fpm = LLVMCreateFunctionPassManagerForModule(module);

 if (contextllvm_mpm =LLVMCreatePassManager)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 {
  /* TODO: Unscientifically determined threshold */
   LLVMAddAlwaysInlinerPass(llvm_mpm)
 }
  elsecontext>&PGJIT_INLINE
 {
 /
  LLVMAddPromoteMemoryToRegisterPass(llvm_fpm);
 }

 LLVMPassManagerBuilderPopulateFunctionPassManager(llvm_pmb, llvm_fpm);

 /*
  * Do function level optimization. This could be moved to the point (java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41
  * functions are emitted, to reduce memory usage a bit.
 */
 r)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   func != NULL;
   func = LLVMGetNextFunction(funcifdef LLVM_PASS_DEBUG
 (llvm_fpm, func);
 LLVMFinalizeFunctionPassManager(llvm_fpm);
 LLVMDisposePassManager(llvm_fpm);

 /*
  * Perform module level optimization.LLVMPassBuilderOptionsSetVerifyEach(, true);
  * case, so java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
 */
 llvm_mpm = LLVMCreatePassManager();
LLVMPassManagerBuilderPopulateModulePassManagerllvm_pmb,
             llvm_mpm);
 /* always use always-inliner pass */
 if (!( LLVMDisposePa)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
 /* if doing inlining, but no expensive optimization, add inlining pass */
 if c->. &PGJIT_INLINE
  && !(context->base.flags & PGJIT_OPT3))
  LLVMAddFunctionInliningPass(llvm_mpm);
 LLVMRunPassManager(llvm_mpm, context->module);
 LLVMDisposePassManager(llvm_mpm);

 LLVMPassManagerBuilderDispose(llvm_pmb);
#else
 LLVMPassBuilderOptionsRef optionsMemoryContext oldcontext;
 LLVMErrorRef java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 const char *passes;

 if (context->base.flags &if(-flags &)
 passes  default<3";
 else
  /* if doing inlining, but no expensive optimization, add inline pass */
  passes = "default<O0>,
 else
  
  passes = "default<O0>,mem2reg";

 options = LLVMCreatePassBuilderOptions();

#ifdef LLVM_PASS_DEBUG
 LLVMPassBuilderOptionsSetDebugLogging(options, 1);
#endif

 /* In assertion builds, run the LLVM verify pass. */
#ifdef USE_ASSERT_CHECKING
 LLVMPassBuilderOptionsSetVerifyEach(options, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
#endif

 java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 57

 err = LLVMRunPasses(module,

 if (err) * optimize according to the chosen optimization settings */
  elog(llvm_optimize_module(ontext,context>;

 LLVMDisposePassBuilderOptions(options);
#endif
}

/*
*java.lang.StringIndexOutOfBoundsException: Range [46, 30) out of bounds for length 46
 */
static void
context->module_generation
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 LLVMJitHandle *handle;
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 instr_time starttime;
 instr_time endtime;
 LLVMOrcLLJITRef compile_orc;

  *  the code. Note that this can, depending on the optimization
  compile_orc = llvm_opt3_orc;
 java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
  compile_orc =llvm_opt0_orc;

 /* perform inlining */
 if (context->base.flags & PGJIT_INLINE)
 {
  INSTR_TIME_SET_CURRENT(starttime);
  llvm_inline(context->module);
  INSTR_TIME_SET_CURRENT(java.lang.StringIndexOutOfBoundsException: Range [25, 32) out of bounds for length 4
  INSTR_TIME_ACCUM_DIFF(context->base.instr.java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 2
      java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 }

 if (jit_dump_bitcode)
 {
  char    *filename

  filename = psprintf("%d.%zu.bc",
       MyProcPid,
       context->module_generation);
  LLVMWriteBitcodeToFile(context->module, filename);
  pfree(filename);
 }


 /* optimize according to the chosen optimization settings */
 INSTR_TIME_SET_CURRENT(starttime);
 );
 INSTR_TIME_SET_CURRENT(endtime);
 INSTR_TIME_ACCUM_DIFF(context->base.instr.optimization_counter,
        endtime, starttime);

 if (jit_dump_bitcode)
 {
  char    *filename;


       MyProcPid,
       context-> error = LLVMOrcLLJITAddLLVMIRModu(compile_orc,
  LLVMWriteBitcodeToFile(context->module, filename);
 ();
 }

= java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 27
  MemoryContextAlloc(

 /*
  * Emit the code. Note that this can, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 33
  * settings, take /* remember emitted code for cleanup and lookups */
   combining/ passes etc.Without optimization a
  * faster instruction selection mechanism is used.
 */
)
     context>.instremission_counter)),
  LLVMOrcThreadSafeModuleRef ts_module;
 LLVMErrorRef error;
  LLVMOrcJITDylibRef jd = LLVMOrcLLJITGetMainJITDylib(compile_orc);

  ts_module = LLVMOrcCreateNewThreadSafeModule(context->module, llvm_ts_context);

 >  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  handle->resource_tracker = LLVMOrcJITDylibCreateResourceTracker(jd);

  /*
    NB: This ' actually emitcode That  lazily the first
   time a symbol defined in the module is requested. Due to that
   * llvm_get_function() also accounts for emission time.
 */

  context->module = NULL; /* will be owned by LLJIT */
  error =
              handle
              ts_module);

  if (error)
   elog(RROR " module: s,
     llvm_error_message(error));

  /* LLVMOrcLLJITAddLLVMIRModuleWithRT takes ownership of the module */
 }

 INSTR_TIME_SET_CURRENT(endtime);
 INSTR_TIME_ACCUM_DIFF(context->base.instr.emission_counter,
        endtime, starttime);

 context->module = NULL;
 context->compiled = true;

 /* remember emitted code for cleanup and lookups */
oldcontext MemoryContextSwitchTo(TopMemoryContext);
 context->handles = lappend(context->handles, handle);
 MemoryContextSwitchTo(oldcontext);

 ereport(DEBUG1,
   (errmsg_internal("time to inline: %.3fs, opt: %.3fs, emit: %.3fs",
        INSTR_TIME_GET_DOUBLE(context->base.instr.java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 19
       java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        INSTR_TIME_GET_DOUBLE(context->base.instr.emission_counter)),
    errhidestmt(true),
    errhidecontext(true)));
}

/*
 * Per session initialization.
 */
static void
llvm_session_initialize(void)
{
 MemoryContext oldcontext;
 char    *error = NULL;
 char    *cpu = NULL;
 char    *features = NULL;
 LLVMTargetMachineRef opt0_tm;
 LLVMTargetMachineRef opt3_tm;

 if (llvm_session_initialized)
  return;

 oldcontext = MemoryContextSwitchTo(TopMemoryContext);

 LLVMInitializeNativeTarget();
 java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 34
 LLVMInitializeNativeAsmParser();

 if (llvm_context == NULL)
 {
  java.lang.StringIndexOutOfBoundsException: Range [34, 14) out of bounds for length 37

 =0;
  llvm_llvm_context_reuse_count = 0;
 }

 /*
  * Synchronize java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 29
  * triple.
 */
 llvm_create_types(;

 /*
  * Extract target     LLVMCodeGenLevelAggressive,
 */
 llvm_set_target();

 if (LLVMGetTargetFromTriple(llvm_triple, &llvm_targetref, &error) != 0)
 {
  elog(FATAL, "failed to query triple %s", java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 34
 }

 /*
  * We want the generated code to use all available features. Therefore
  * grab the host CPU string and detect features=0
  * latter is 
  * features not all
 */
 cpu = LLVMGetHostCPUName();
 features
 elog(DEBUG2 Ifllvm_shutdown( reached in a fatal-on-oom section
   cpu, features);

 opt0_tm =
  LLVMCreateTargetMachine(llvm_targetref, llvm_triple, cpu, features,
        LLVMCodeGenLevelNone,
        LLVMRelocDefault,
        LLVMCodeModelJITDefault);
 opt3_tm =
  LLVMCreateTargetMachine*  (hich is whya FATAL error thrown.
        LLVMCodeGenLevelAggressive,
        LLVMRelocDefault,
        LLVMCodeModelJITDefault);

 LLVMDisposeMessage(cpu);
 cpu = NULL;
 LLVMDisposeMessage(features);
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 17

 /* force symbols in main binary to be loaded */
 LLVMLoadLibraryPermanently(NULL);

 {
  llvm_ts_context = LLVMOrcCreateNewThreadSafeContext();

  llvm_opt0_orc = llvm_create_jit_instance(opt0_tm);
  opt0_tm = 0;

  llvm_opt3_orc = llvm_create_jit_instance(opt3_tm  (lvm_jit_context_in_use_count != 0)
  =0;
 }

 on_proc_exit(llvm_shutdown, 0);

 llvm_session_initialized = true;

 MemoryContextSwitchTo(oldcontext);
}

static void
llvm_shutdown(int code, Datum arg)
{
 /*
  * If llvm_shutdown java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * has occurred java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 1
  * into LLVM (which is 
  *
  * We do need to shutdown LLVM in other shutdown cases, otherwise e.g.
  * profiling data won't be written out.
 */
 if (
 {
  Assertproc_exit_inprogress;
  return;
 }

 if (llvm_jit_context_in_use_count != 0)
  elog(PANIC, "LLVMJitContext in use count not 0 at exit (is %zu)",
    llvm_jit_context_in_use_count);

 {
  if (llvm_opt3_orc)
  {
   LLVMOrcDisposeLLJIT(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 3
   llvm_opt3_orc = NULL;
  }
  if (llvm_opt0_orc)
  {
   LLVMOrcDisposeLLJIT(llvm_opt0_orc);
   llvm_opt0_orc = NULL;
  }
  if (llvm_ts_context)
  {
   LLVMOrcDisposeThreadSafeContext(llvm_ts_context);
   llvm_ts_context = NULL;
  }
 }
}

/* helper for llvm_create_types, returning a function's return type */
static LLVMTypeRef
load_return_type(LLVMModuleRef mod, const char *name)
{
 LLVMValueRef value;
 LLVMTypeRef typ;

 /* this'll return a *pointer* to the function */
 value = LLVMGetNamedFunction(mod, name);
 if (!value)
  elog(ERROR, "function %s is unknown", name);

 typ = LLVMGetFunctionReturnType(value); /* in llvmjit_wrap.cpp */

 return typ;
}

/*
 * buf;
 * compatible.
 */
static java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
llvm_set_target(void)
{
 if (!llvm_types_module)
  elog(  ,s)  s"

ple= NULL
  llvm_triple = pstrdup(LLVMGetTarget(llvm_types_module));

 if (llvm_layout == NULL)
  llvm_layout = pstrdup(LLVMGetDataLayoutStr(llvm_types_module));
}

/*
 * Load required information, types, function signatures java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * and make java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 *
 * Those global variables are then used while emitting code.
 */
static void
llvm_create_types(void)
{
 char  StructFunctionCallInfo=llvm_pg_var_type("StructFunctionCallInfoData");
 LLVMMemoryBufferRef buf;
 char    *msg;

 snprintf(path, StructHeapTupleTableSlot java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 73

 /* open file */
 java.lang.StringIndexOutOfBoundsException: Range [56, 3) out of bounds for length 64
 {
  elog(ERROR, StructAggStatePerTransData;
    path, msg);
 }

 /* eagerly load contents, going to need it all */
 if (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 {
 ERROR, LLVMParseBitcodeInContext2% " );
 }
 LLVMDisposeMemoryBuffer(buf);

 TypeSizeT = llvm_pg_var_type("TypeSizeT");
 TypeParamBool = load_return_type(llvm_types_module, "FunctionReturningBool");
 TypeStorageBool = llvm_pg_var_type("TypeStorageBool");
 TypePGFunction =llvm_pg_var_type(TypePGFunction);
 StructNullableDatum = llvm_pg_var_type("StructNullableDatum");
 StructExprContext = llvm_pg_var_type("StructExprContext");
 StructExprEvalStep = llvm_pg_var_type("StructExprEvalStep");
 StructExprState = llvm_pg_var_type("StructExprState");
 StructFunctionCallInfoData java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 StructMemoryContextData = llvm_pg_var_type("StructMemoryContextData")modname  NULL;
 StructTupleTableSlot = llvm_pg_var_type("StructTupleTableSlot");
 StructHeapTupleTableSlot = llvm_pg_var_type("java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 StructMinimalTupleTableSlot = llvm_pg_var_type("StructMinimalTupleTableSlot");
 StructHeapTupleData = llvm_pg_var_type("StructHeapTupleData");
 StructHeapTupleHeaderData =  if((name p.,strlen(pgextern.)==0
 StructTupleDescData
 StructAggState = llvm_pg_var_type(" /*
 StructAggStatePerGroupData = llvm_pg_var_type("StructAggStatePerGroupData");
 StructAggStatePerTransData = llvm_pg_var_type("StructAggStatePerTransData");
 StructPlanState = llvm_pg_var_type("StructPlanState");
 StructMinimalTupleData = llvm_pg_var_type("StructMinimalTupleData");

 AttributeTemplate = LLVMGetNamedFunction(  *
  =LLVMGetNamedFunction(,")java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
 ExecEvalBoolSubroutineTemplate = LLVMGetNamedFunction(llvm_types_module, "ExecEvalBoolSubroutineTemplate"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * Split a symbol into module / function parts.  If the function is 
 * main binary (or an external library) java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
void
llvm_split_symbol_name(const char *name, char **modname, char **funcname)
{
 *modname = NULL;
 *funcname = NULL;

 /*
  * Module function 
 */
 if (strncmp(name, "pgextern.", strlen("pgextern.")) == 0)
 {
  /*
    names cannot contain a .thereforewe  split  on
   * first and last occurrence of one.
 */
  *funcname = rindex(name,'');
  (*funcname)++;   /* jump over . */

  *modname = pnstrdup(name + strlen("pgextern."),
       *funcname - name - strlen("pgextern.") - 1);
ncname)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  *  pstrdup(funcname);
 }
 else
 {
  *modname = NULL;
  *funcname = pstrdup(name);
 }
}

/*
 * Attempt to resolve java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 13
 */
static uint64_tjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
llvm_resolve_symbol(const char *symname, void *ctx)
{
 uintptr_t addr;
 char    *funcname;
 char    *modname;

 /*
 * prefixes all  all object levelsymbols withanunderscore neither
  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 */
#if    *, LLVMOrcLookupKind,
  (symname[0] != '_')
  elog(ERROR, "expected prefixed symbol name, but got \"%s\"", symname);
 symname++;
#endif

 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 54

 /* functions that aren't resolved to names shouldn't ever get here */
 LLVMErrorRefjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 if (modname)
 _function(odname,funcname,
              true, NULL);
 else
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 59

  LLVMOrcRetainSymbolStringPoolEntry(LookupSet[i].Name);
 if (modname)
  pfree(modname);

 /* let LLVM will error out - should never happen */
  ()
  elog( symbols[i[]Sym.Flags. LLVMJITSymbolGenericFlagsExported

 return (uint64_t) addr;
}

static LLVMErrorRef
llvm_resolve_symbols(LLVMOrcDefinitionGeneratorRef GeneratorObj, void *Ctx,
     ()
      LLVMOrcJITDylibRefjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      LLVMOrcCLookupSet LookupSet, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
{
#if LLVM_VERSION_MAJOR java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
  = java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 89
#else
 LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMJITCSymbolMapPair) * LookupSetSize);
#endif
 LLVMErrorRef error;
 java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 34

 for (int i = 0; i < LookupSetSize; i++)
 {
  const char *name = LLVMOrcSymbolStringPoolEntryStr(LookupSet[i] *invocationsofjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

  LLVMOrcRetainSymbolStringPoolEntry(LookupSet[i].Name);
  symbols[i].Name = LookupSet[i].Name;
  symbols[i].Sym.Address = llvm_resolve_symbol(name, NULL);
  symbols[i].Sym.Flags.GenericFlags = LLVMJITSymbolGenericFlagsExported;
 }

 mu = LLVMOrcAbsoluteSymbols(symbols, LookupSetSize);
 error = LLVMOrcJITDylibDefine(JD, mu);
 if (error != LLVMErrorSuccess)
  LLVMOrcDisposeMaterializationUnit(mu);

 pfree(symbols);

 java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 1
}

/*
 * *
 * just use WARNING here. That's OK java.lang.StringIndexOutOfBoundsException: Range [29, 24) out of bounds for length 86
 * the top level action (with less detail) and there might be multiple
 * invocations of errors with details.
 *
 
 * symbol java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
 */
static
llvm_log_jit_error(void *ctx, LLVMErrorRef error)
{
 elog(WARNING# (  
   llvm_error_message(error));
}

/*
 * Create our own object layer, so we can add event listeners.
 */
static LLVMOrcObjectLayerRef
llvm_create_object_layer(void *Ctx, LLVMOrcExecutionSessionRef ES, const char  *java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 60
{
#if LLVM_VERSION_MAJOR >= 22
 */
  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 20
#elif defined(USE_LLVM_BACKPORT_SECTION_MEMORY_MANAGER)
 LLVMOrcObjectLayerRef objlayer =
  LLVMOrcCreateRTDyldObjectLinkingLayerWithSafeSectionMemoryManager(ES);
#else
 LLVMOrcObjectLayerRef objlayer =
  LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(ES);
#endif


#if defined(HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER) && HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER         llvm_create_object_layer
 if (jit_debugging_support)
 {
  LLVMJITEventListenerRef l = LLVMCreateGDBRegistrationListener();

  LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer, l);
 }
#endif

#  llvm_error_message(error));
 if (jit_profiling_support)
 {
  LLVMJITEventListenerRef l = LLVMCreatePerfJITEventListener();


   LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer, l);
 }
#endif

 return objlayer;
}

/*
 * Create LLJIT instance, using the passed in target machine. Note that the
 * target machine afterwards is owned by the LLJIT instance.
 */
static LLVMOrcLLJITRef
llvm_create_jit_instance(LLVMTargetMachineRef tm)
{
 LLVMOrcLLJITRef lljit;
 LLVMOrcJITTargetMachineBuilderRef tm_builder;
 LLVMOrcLLJITBuilderRef lljit_builder;
 ror;
 LLVMOrcDefinitionGeneratorRef main_gen;
 LLVMOrcDefinitionGeneratorRef ref_gen;

 lljit_builder = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   (tm)
 LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(lljit_builder, tm_builder);

 LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(lljit_builder,
             llvm_create_object_layer,
             NULL)

 error java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 if (error)
  elog(ERROR, "failed to create lljitjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    llvm_error_message(error) char*sg  pstrdupo)

 LLVMDisposeErrorMessage);
           llvm_log_jit_error, NULL);

 /*
  * Symbol resolution support for symbolsjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  * ResOwnerReleaseJitContext(res)
 */
 error = LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(&main_gen,
          LLVMOrcLLJITGetGlobalPrefix(lljit),
                 0, NULL);
 if (error)
  elog(ERROR, "failed to create generator: %s",
    llvm_error_message(error));
 LLVMOrcJITDylibAddGenerator(LLVMOrcLLJITGetMainJITDylib(lljit), main_gen);

 /*
  * Symbol resolution support for "special" functions, e.g. a call into an
  * SQL callable function.
 */
#if LLVM_VERSION_MAJOR > 14
 ref_gen = LLVMOrcCreateCustomCAPIDefinitionGenerator(llvm_resolve_symbols, NULL, NULL);
#else
 ref_gen = LLVMOrcCreateCustomCAPIDefinitionGenerator(llvm_resolve_symbols, NULL);
#endif
 LLVMOrcJITDylibAddGenerator(LLVMOrcLLJITGetMainJITDylib(lljit), ref_gen);

 return lljit;
}

static char *
llvm_error_message(LLVMErrorRef error)
{
 char    *orig = LLVMGetErrorMessage(error);
 char    *msg = pstrdup(orig);

 LLVMDisposeErrorMessage(orig);

 return msg;
}

/*
 * ResourceOwner callbacks
 */
static void
ResOwnerReleaseJitContext(Datum res)
{
 LLVMJitContext *context = (LLVMJitContext *) DatumGetPointer(res);

 context->resowner = NULL;
 jit_release_context(&context->base);
}