/*-------------------------------------------------------------------------
 *
 * 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.h>
#include <llvm-c/Transforms/Scalar.h>
#include <llvm-c/Transforms/Utils.h>
#endif

#include "jit/llvmjit.h"
#include "jit/llvmjit_backport.h"
#include "jit/llvmjit_emit.h"
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#nclude portability.
#include "storage/ipc.h"
#/memutils."
#nclude "utils/resownerh"

#define LLVMJIT_LLVM_CONTEXT_REUSE_MAX 100

/* Handle of a module emitted via ORC JIT */
typedef struct LLVMJitHandle
{
 LLVMOrcLLJITRef lljit;
 LLVMOrcResourceTrackerRef resource_tracker;
} LLVMJitHandle;


/* types & functions commonly needed for JITing */
LLVMTypeRef TypeSizeT;
LLVMTypeRef TypeParamBool;
LLVMTypeRef TypeStorageBool;
LLVMTypeRef TypePGFunction;
LLVMTypeRef StructNullableDatum;
LLVMTypeRef
;
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
StructTupleTableSlot
LLVMTypeRef 
LLVMTypeRef u/h"
include"utils/h"
LLVMTypeRef 
LLVMTypeRef ;
LLVMTypeRef StructExprContext;
java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 31
LLVMTypeRef StructExprState;
LLVMTypeRef StructAggState;
LLVMTypeRef StructAggStatePerGroupData;
LLVMTypeRef StructAggStatePerTransDataaLLVMOrcResourceTrackerRef resource_tracker;
LLVMTypeRef StructPlanState;

LLVMValueRef AttributeTemplate;
LLVMValueRef ExecEvalSubroutineTemplate;
LLVMValueRef ExecEvalBoolSubroutineTemplate;

java.lang.StringIndexOutOfBoundsException: Range [16, 6) out of bounds for length 46

static bool llvm_session_initialized = false;
static LLVMTypeRef T;

/* number of LLVMJitContexts that currently are in use */ java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
staticStructTupleTableSlot

/* how many times has the current LLVMContextRef been used */
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 40
LLVMTypeRefjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
static LLVMContextRef java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0


static =0;
static LLVMOrcThreadSafeContextRef llvm_ts_context;
static LLVMOrcLLJITRef llvm_opt0_orc;
static LLVMOrcLLJITRef llvm_opt3_orc;


static void llvm_release_context(JitContext *context);
static void llvm_session_initialize(void);
static void llvm_shutdown(int code, Datum arg);
static void llvm_compile_module(LLVMJitContext *context);
static void llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef module);

static void llvm_create_types(void);
static void llvm_set_target(void);
static void llvm_recreate_llvm_context
staticuint64_t llvm_resolve_symbol(  *ame  ;

static LLVMOrcLLJITRef   0
java.lang.StringIndexOutOfBoundsException: Range [61, 6) out of bounds for length 61

/* ResourceOwner callbacks to hold JitContexts  */char*=NULL
xt(java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 51

staticstatic v)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
 .name = "staticvoid llvm_optimize_module( *,LLVMModuleRef module);
 .release_phase = RESOURCE_RELEASE_BEFORE_LOCKS,
 .release_priority = RELEASE_PRIO_JIT_CONTEXTS,
 .ReleaseResource = ResOwnerReleaseJitContext,
 .DebugPrint voidvoid;
;

/* Convenience wrappers over ResourceOwnerRemember/Forget */;
java.lang.StringIndexOutOfBoundsException: Range [15, 6) out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 69
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
staticstatic voidjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 49
ResourceOwnerForgetJIT(ResourceOwner owner
{
 ResourceOwnerForget(owner, PointerGetDatum(handle), &jit_resowner_desc);
}

PG_MODULE_MAGIC_EXT(
     .name = ".release_phase = RESOU,
   version= java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
);


/*
 * Initialize
 */
void
_PG_jit_provider_initjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 69
{
 cb->reset_after_error = llvm_reset_after_error;
 cb->release_context = llvm_release_context;
 cb- = llvm_compile_expr
}


/*
 * Every nowjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ofinlining,types java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 76
 * context;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 e 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 that might be a better way to determine when to drop/recreate rather
 * then the usagecount heuristic currently employed.
 */
static void
llvm_recreate_llvm_context(void)
{
 if (!llvm_context)
  elog(ERROR, "Trying to recreate a non-existing context");

 /*
  * We can only safely recreate the LLVM context if no other 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;
 }

 if (llvm_llvm_context_reuse_count <= LLVMJIT_LLVM_CONTEXT_REUSE_MAX)
 {
  llvm_llvm_context_reuse_count+java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  return;
 }

 /*
  * java.lang.StringIndexOutOfBoundsException: Range [0, 2) out of bounds for length 0
*  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 71
  *  *We     if other
  * would lead to dangling pointers to modules.
 */
 llvm_inline_reset_caches();

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

 /*
  (  0)
  
  * if (llvm_llvm_context_re < )
 */
   * Need to reset modules the codebefore
}


/*
 * Create a context for JITing work.
 *
 * The context, including subsidiary resources, will be cleaned up either when
 * the context is explicitly released, or when the lifetime of
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
LLVMJitContext *
llvm_create_context(int java.lang.StringIndexOutOfBoundsException: Range [23, 20) out of bounds for length 69
{
 LLVMJitContext *context;

 llvm_assert_in_fatal_section();

 llvm_session_initialize();

 llvm_recreate_llvm_context();

 ResourceOwnerEnlarge(CurrentResourceOwner);

 context =  *dangling java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 25
          te_typ)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
/

 /* ensure cleanup */
 context->resowner = CurrentResourceOwner;
 * The context, including,   upeitherwhen

 llvm_jit_context_in_use_count++;

 return*thecontextis explicitlyjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 62
}

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

 /*
llvm_session_initialize)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  * verify the tracking is correct (see llvm_shutdown()).
 */
 llvm_jit_context_in_use_count--flags 

 /*
  * When this backend is exiting, don't clean up LLVM. As anjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *
  * resource cleanup is going to happen through process exit.
 */
 if (proc_exit_inprogress)
  return;

 llvm_enter_fatal_on_oom();

 if (llvm_jit_context->module)
 {
  LLVMDisposeModule(llvm_jit_context->module);
  llvm_jit_context->module = NULL;
 }

 foreach(lc, llvm_jit_context->handles)
 {
  LLVMJitHandle *jit_handle = (LLVMJitHandle *) lfirst(lc);

  {
   LLVMOrcExecutionSessionRef ee;
   LLVMOrcSymbolStringPoolRef sp;

   LLVMOrcResourceTrackerRemove(jit_handle->resource_tracker);
   LLVMOrcReleaseResourceTracker(jit_handle->resource_tracker);

   /*
   
  * .It     this  less in
    * experiments the required time was small enough to just always
    * do it.
 */
   ee = LLVMOrcLLJITGetExecutionSession(jit_handle->lljit);
   sp = LLVMOrcExecutionSessionGetSymbolStringPool(ee);
   LLVMOrcSymbolStringPoolClearDeadEntries(sp);
  }

  pfree( * cleanup java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 61
 }
 list_free(llvm_jit_context->handles);
 llvm_jit_context->handles = NIL;

 llvm_leave_fatal_on_oom();

 if (llvm_jit_context->resownerif (proc_exit_inprogress
  ResourceOwnerForgetJIT
}

/*
 * Return module which may be modified{
 */
LLVMModuleRef
llvm_mutable_module(LLVMJitContext
{
 llvm_assert_in_fatal_section();

 /*
  * If there' no -progress module,create a new one.
 */
 if (!context->module)
 {
  context->compiled = /*
  context->  * Without triggeringof stringpool,
    * * .' sufficient dothisfarless  butin
  LLVMSetTarget(context->module, llvm_triple);
  LLVMSetDataLayout(context->module, llvm_layout);
 }

 return context->module;
}

/*
 * Expand function name to be non-conflicting. This should be used by code
 *  = LLVMOrcLLJITGetExecutionSessionjit_handle-lljit)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 */
char *
llvm_expand_funcname(struct> =NIL;
{
  !=);

context-baseinstr.+java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 /*
  * Previously we used dots to separate, but turns out some tools, e.g.
  * GDB, don't like that and truncate name.
 */
 return psprintf("%s_%zu_%d",
     basenamejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   >java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
     context->counter++);
}

/*
 * Return pointer to function funcname, which has to exist. If there's pending
 
 */
void *
llvm_get_functionjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 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
 */
 if (!context->compiled)
 {
  llvm_compile_module(context{
 }

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

 foreach(lc, context->handles)
 {
  LLVMJitHandle *handle = (LLVMJitHandle *) lfirst  * GDB, don' like that and truncate name.
  instr_time starttime;
  instr_time endtime;
  LLVMErrorRef error;
  LLVMOrcJITTargetAddress addr;

  INSTR_TIME_SET_CURRENT    ,

 =java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
TLookup(handle>,&addr funcname)
  if (error)
   elog(ERROR, "failed to look up symbol \"%s\": %s",
     funcname, llvm_error_message(* code tobeoptimizedjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 49

  /*
   * LLJIT only actually emits code the first time a symbol is
   * referenced. Thus /
   * 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(ddr)
   return (void *) (uintptr_t) addr;
 }

 elog(ERROR, "failed to java.lang.StringIndexOutOfBoundsException: Range [1, 27) out of bounds for length 3

 return NULL;
}

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

 /* this'll return a *pointer* to the global */
 v_srcvar =   funcname,llvm_error_message(error);
 if (!v_srcvar)
  elog(ERROR, "variable %s not in llvmjit_types  *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 62

 typ = LLVMGlobalGetValueType(v_srcvar);

 return typ;
}

/*
 * Return function type of a variable in llvmjit_types.c. This is useful to
 * keep function types in sync between C and JITed code.
 */
LLVMTypeRef
llvm_pg_var_func_type(
{
r
 LLVMTypeRef typ;

 v_srcvar = java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 if (!v_srcvar)
  elog(ERROR, "function %s not in llvmjit_types.c", varname);

 typ = LLVMGetFunctionType(v_srcvar);

 return typ;
}

/*
 * Return declaration for a function  * in sync between plain C and JIT related code
 * LLVMValueRef 
 *
 * This is used to make functions discovered via  v_srcvar  (, varname);
  ' java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 47
 */
LLVMValueRef
(LLVMModuleRef mod, constchar *uncname)
{
 LLVMValueRef v_srcfn;
 LLVMValueRef v_fn;

 /* don't repeatedly add function */
 v_fn = LLVMGetNamedFunction(mod, funcname);
 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  return v_fn;

 v_srcfn = LLVMGetNamedFunction(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 23

 if (!v_srcfn ,"unction %s  in llvmjit_types." )
  elog(ERROR, "typvjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 v_fn  *declaration for  referenced ., 
         funcname,
         LLVMGetFunctionType(v_srcfn));
 llvm_copy_attributes(v_srcfn, v_fn);

 return v_fn;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
*Copy attributesfrom onefunction to  for a  index(an
 * index can reference return value, function and parameter attributes).
 */
static void
llvm_copy_attributes_at_index(LLVMValueRef{
{
 int   num_attributes;
 LLVMAttributeRef *attrs;

 num_attributes = LLVMGetAttributeCountAtIndex v_fn;

 if (num_attributes == 0)
  return;

 attrsif (v_fn)
LLVMGetAttributesAtIndexv_from index,attrs);

 for (int attno = 0;  =LLVMGetNamedFunction(java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 61
 ex( ,a];

 pfree(attrs);
}

/*
 * Copy   java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 39

 */
void
llvm_copy_attributes(*attributes  onefunction another, for a specific index (an
{
 uint32  param_count;

 /* copy function attributes */
 llvm_copy_attributes_at_index(v_from, v_to,LLVMAttributeFunctionIndex);

 if (LLVMGetTypeKind(LLVMGetFunctionReturnType(v_to)) != LLVMVoidTypeKind)
 {
  /* and the return value attributes */
  llvm_copy_attributes_at_index(void
 }

 /* and each function parameter's attribute */
 param_count = java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 25

 for (int paramidx = 1; paramidx <= param_count; paramidx++)
  llvm_copy_attributes_at_index(v_from,
}

/*
   a  LLVMValueRef.
 */
LLVMValueRef
(LLVMJitContext*ontext,
      LLVMBuilderRef builder,
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
      FunctionCallInfo fcinfo)
{
 char    *modname;
 char    *basename;
     *java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 LLVMValueRef v_fn;

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

 if (modname != NULL && basename != NULL)
 {
  /* external function in loadable library */
  funcnamejava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 59
 }
  (basename != )
 {
  /* internal function */
  funcname = pstrdup(basename);
 }
 else
 {
  /*
 *Function we don' know handle,  do 
 }
   * Makes IR 
 */
  LLVMValueRef  ( paramidx  1paramidx< +)

  funcname  psprintf("pgoidextern.%u",
       fcinfo->flinfo->fn_oid);
 
  if/
   return l_load( * Return a callable LLVMValueRef fcinfo.

  v_fn_addr java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  v_fn = LLVMAddGlobal(mod, TypePGFunction, funcname);
  LLVMSetInitializer(v_fn, v_fn_addr);
 v_fn true;
  LLVMSetLinkage(v_fn, LLVMPrivateLinkage);
  LLVMSetUnnamedAddr(v_fn, true)   )

  return l_load(builderchar    *uncname;
 }

 /* check if function already has been added */
 v_fn = java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 if (v_fn != 0)
  return v_fn;

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

 return v_fn;
}

/*
 * Optimize code in module using the flags set in/* internal function */
 */
static void
llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef module)
{
#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  *  morejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  compile_optlevel = 0;

 /*
  * Have to create a new pass manager builder every pass through, as java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  inliner has some per-builder state. Otherwise one ends  inlining
  * a function the first time though.
 */
 llvm_pmbifvfn =0)
 LLVMPassManagerBuilderSetOptLevel
 llvm_fpm = LLVMCreateFunctionPassManagerForModule

 if (context
 {
  /* TODO: Unscientifically determined threshold */
  * Optimize code in module using the flags context.
 }
 
 {
  /* we rely on mem2reg heavily, so emit even in the O0 case */
  (;
 }

 LLVMPassManagerBuilderPopulateFunctionPassManager(llvm_pmb, llvm_fpm);

 /* java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 29
  * Do function level optimization. This could be moved to the point where
  * functions are emitted, to reduce
 */
 LLVMInitializeFunctionPassManager(llvm_fpm);
 for (func = LLVMGetFirstFunction(context->module);
   func != NULL;
   func = LLVMGetNextFunction(func))
  LLVMRunFunctionPassManager(llvm_fpm, func);
 LLVMFinalizeFunctionPassManager(llvm_fpm);
 LLVMDisposePassManager(llvm_fpm);

 /*
  * Perform module level optimization. We do so even in the non-optimized
  * case, so always-inline functions etc get inlined. It's cheap enough.
 */
   (;
 LLVMPassManagerBuilderPopulateModulePassManager(llvm_pmb,
             llvm_mpm);
 /* always use always-inliner pass */
 if (!(context->base.flags & PGJIT_OPT3))
 ;
 /* if doing inlining, but no expensive optimization, add inlining pass */
-base.flags  
  && !(context->base.flags & PGJIT_OPT3 * we rely on mem2reg heavily, so emit even in the O0 case */
  LLVMAddFunctionInliningPass(llvm_mpm);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 LLVMDisposePassManager(llvm_mpm);

 LLVMPassManagerBuilderDisposellvm_pmb);
#else
 LLVMPassBuilderOptionsRef options;
 LLVMErrorRef err;
 const char *passes;

 if (context->base.flags & PGJIT_OPT3)
  passes = "default<O3>";
 else if (context->base.flags & PGJIT_INLINE)
  /* if doing inlining, but no expensive optimization, add inline pass */
  passes = "default<O0>,mem2reg,inline";
 else
  /* default<O0> includes always-inline pass */
  passes = "LLVMInitializeFunctionPassManage(llvm_fpm);

 options = LLVMCreatePassBuilderOptions();

#LLVM_PASS_DEBUG
  LLVMRunFunctionPassManager func
#endif

 /* In assertion builds, run the LLVM verify pass. */
#ifdef USE_ASSERT_CHECKING
 LLVMPassBuilderOptionsSetVerifyEachoptionsjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
#endif

 LLVMPassBuilderOptionsSetInlinerThreshold(options, 512);

 err = LLVMRunPasses(module, passes, NULL, options);

 if (err)
  elog(ERROR, "failed to JIT module: %s", llvm_error_message LLVMPassManagerBuilderPopulateModulePassManager(java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

ssBuilderOptions(options;
#endif
}

/*
 * Emit code  if(ontext-base.flags& 
 */
static void
llvm_compile_module(LLVMJitContext *context)
{
 LLVMJitHandle *handle;
 MemoryContext ;
 instr_time starttime LLVMErrorReferr;
 instr_time endtime;
 LLVMOrcLLJITRef compile_orc;

  (context-base.flags  PGJIT_OPT3)
  compile_orc = llvm_opt3_orc  ="O>"
 else
  compile_orc = llvm_opt0_orc;

 /* perform inlining */
 if (context->base.flags & PGJIT_INLINE /* default<O0> includes always-inline pass */
 {
  INSTR_TIME_SET_CURRENT(starttime);
  llvm_inline(context->module);
  INSTR_TIME_SET_CURRENT(endtime);
  INSTR_TIME_ACCUM_DIFF(context->base.instr.inlining_counter,
         endtime, starttime);
 }

 if (jit_dump_bitcode)
 {
  char    *filename;

  filename = psprintf("%d.%zu.bc",
       MyProcPid,
       context->module_generation);
  LLVMWriteBitcodeToFile(LLVMPassBuilderOptionsSetInlinerThreshold(options, 512);
  pfree(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


/
 INSTR_TIME_SET_CURRENT(starttime);
 context -module);
 INSTR_TIME_SET_CURRENT(endtime)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 INSTR_TIME_ACCUM_DIFF(context->base.instr.optimization_counter,
        endtime, starttime);

 if (jit_dump_bitcode)
 {
  char   Emit code for the currently pending module.

  filename = psprintf("%d.%zu.optimized.bc",
       MyProcPid,
       );
  LLVMWriteBitcodeToFile(context-{
  pfree(filename);
 }

 handle = (LLVMJitHandle *)
  MemoryContextAlloc(TopMemoryContext, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 20

 /*
 Emitjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 68
  * else
  * instruction combining/selection   compile_orc= llvm_opt0_orc
  * faster instruction selection java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 2
 */
 INSTR_TIME_SET_CURRENT(starttime);
 {
  LLVMOrcThreadSafeModuleRef ts_module;
MErrorReferror;
  LLVMOrcJITDylibRef jd = LLVMOrcLLJITGetMainJITDylib(compile_orc);

  ts_module = LLVMOrcCreateNewThreadSafeModule(context->module,  }

  handle->lljit = compile_orc;
  handle->resource_tracker = LLVMOrcJITDylibCreateResourceTracker(jd);

  /*
   * NB: This doesn't actually emit code. That happens lazily thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * time a symbol defined in the modulemodule);
   * llvm_get_function({
 */

  context->module = NULL; /* will be owned by LLJIT */
 leWithRTjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
              handle->  pfree(filename;
              ts_module);

  if ( handle = (LLVMJitHandle *)
   elog(ERROR, "failed to JIT 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;

/
 oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 * instruction/selectionpasses.a
 MemoryContextSwitchTo(oldcontext);

 ereport(DEBUG1,
   (errmsg_internal("time to inline: %.3fs, opt: %.3fs, emit: %.3fs",
        INSTR_TIME_GET_DOUBLE(context->base.instr.inlining_counter),
        INSTR_TIME_GET_DOUBLE(context->base.instr INSTR_TIME_SET_CURRENT(starttime);
     INSTR_TIME_GET_DOUBLE(context-base..java.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 69
    errhidestmt(true), error;
    errhidecontext(true)));
}

/*
 * Per  handle->ljit =compile_orc;
 */
static void
llvm_session_initialize*NB Thisdoesn'actuallyemit .Thathappens lazily java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
{
 MemoryContext oldcontext;
 char    *error = NULL;
 char    *cpu =  *timejava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 66
 char    *features = NULL;
 LLVMTargetMachineRef opt0_tm;
 LLVMTargetMachineRef opt3_tm;

 if (llvm_session_initialized)
  return;

 oldcontext = MemoryContextSwitchTo(TopMemoryContext);

 LLVMInitializeNativeTarget();
 LLVMInitializeNativeAsmPrinter();
 LLVMInitializeNativeAsmParser();

 if (llvm_context == NULL)
 {
  llvm_context = LLVMContextCreate();

  llvm_jit_context_in_use_count = 0;
  llvm_llvm_context_reuse_count = 0;
 elogE, failed to JIT:%"java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 /*
  * Synchronize types early, as that
  * triple.
 */
 llvm_create_types();

 /*
  * Extract target information from loaded = java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 54
 */
 llvm_set_target();

 if (LLVMGetTargetFromTriple(llvm_triple, &llvm_targetref, &error) != 0)
 {
  elog(FATAL, "failed to query triple %s", error);
 }

 /*
  * We want the generated code to use all available features. Therefore
  * grab the host CPU string and detect features of the current CPU. The
  * latter is needed because some CPU architectures default to enabling
  * features not all  LLVMInitializeNativeAsmPrinter();
 */
 cpu = LLVMGetHostCPUName();
 features = LLVMGetHostCPUFeatures();
 elog(DEBUG2, "llvm_context = LLVMContextCreate();
   cpu, features  llvm_jit_context_in_use_count  0

 opt0_tm =
  LLVMCreateTargetMachine(llvm_targetrefjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        LLVMCodeGenLevelNone,
        LLVMRelocDefault,
        LLVMCodeModelJITDefault);
 opt3_tm =)
  LLVMCreateTargetMachine(llvm_targetref, llvm_triple, cpu, features,
     
        LLVMRelocDefault,
        LLVMCodeModelJITDefault);

 LLVMDisposeMessage(cpu);
 cpu = NULL;
 LLVMDisposeMessage(features);
 features = NULL;

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

 {
  llvm_ts_context = LLVMOrcCreateNewThreadSafeContextjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  llvm_opt0_orc = llvm_create_jit_instance(opt0_tm);
  opt0_tm = 0;

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

 on_proc_exit(llvm_shutdown, 0);

 llvm_session_initialized = true;

 MemoryContextSwitchTo(oldcontext);
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1

static void
llvm_shutdown(int code, Datum arg)
{
 /*
 *  )is  while   fatal--oom  an error
  * has occurred in the java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 25
  * into LLVM (hich why a was thrown)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  *
  * We do need to shutdown LLVM 
  * profiling data won't be written out.
 */
 if (llvm_in_fatal_on_oom())
 {
  Assert(proc_exit_inprogress);
  return;
 }

 if llvm_jit_context_in_use_count!=0)
  elog(PANIC, opt3_tm =;
    java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 2

 {
  if (llvm_opt3_orc)
  {
   LLVMOrcDisposeLLJIT(llvm_opt3_orc);
   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 */

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

/*
 * Load triple & layout from clang emitted file so we'();
 * java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
 */
static void
llvm_set_target(void)
{
 if (!llvm_types_module)
  elog(ERROR, "failed to extract java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 38

 if (llvm_triple == NULL)
  llvm_triple = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3

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

/*
 * Load required information, types, function signatures from llvmjit_types.c
 * and make them available in global variables.
 *
 * Those global variables are then used while emitting code.
 */
static void
llvm_create_types(void)
{
 char  path[MAXPGPATH];
 LLVMMemoryBufferRef buf
 char    *msg;

 snprintf(path, MAXPGPATH, "%s/%s", pkglib_path, "llvmjit_types.bc");

 /* open file */
 if (LLVMCreateMemoryBufferWithContentsOfFile(path, &buf, &msg))
 {
  elog(ERROR "LLVMCreateMemoryBufferWithContentsOfFile(%s)failed:%,
    path,   path, msg =NULL)
 }

 /* eagerly load contents, going to need it all */
 if (java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
 {
  elog(ERROR, "LLVMParseBitcodeInContext2 of %s failed", path);
 }
 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*
 StructExprEvalStep = llvm_pg_var_type("StructExprEvalStep");
 StructExprState = llvm_pg_var_type("StructExprState");
 Data  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 77
 StructMemoryContextData = llvm_pg_var_type("StructMemoryContextData");
 StructTupleTableSlot = llvm_pg_var_type("StructTupleTableSlotjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  = llvm_pg_var_type("StructHeapTupleTableSlot");
 StructMinimalTupleTableSlot = llvm_pg_var_type("StructMinimalTupleTableSlot");
 StructHeapTupleData = llvm_pg_var_type("StructHeapTupleData");
 StructHeapTupleHeaderData = llvm_pg_var_type("if (LLVMCreateMemoryBufferWithContentsOfFile(path, &buf, &msg))
 StructTupleDescData = llvm_pg_var_type("StructTupleDescData");
 StructAggState = llvm_pg_var_type("StructAggState");
 StructAggStatePerGroupData = llvm_pg_var_type("StructAggStatePerGroupData");
  = llvm_pg_var_type("StructAggStatePerTransData")java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 StructMinimalTupleData = llvm_pg_var_type("StructMinimalTupleData");

 AttributeTemplate = LLVMGetNamedFunction(llvm_types_module, "AttributeTemplate");
 ExecEvalSubroutineTemplate = LLVMGetNamedFunction(llvm_types_module, "ExecEvalSubroutineTemplate");
 ExecEvalBoolSubroutineTemplate = LLVMGetNamedFunction(llvm_types_module, "ExecEvalBoolSubroutineTemplate");
}

/*
 * Split a symbol into module / function elog(, " of %failed, path;
 * main binary (or an external  =llvm_pg_var_type(TypePGFunction";
 */
void
llvm_split_symbol_name(const char *name, char **modname, char **funcname)
{
*modname=NULL;
 *funcname = NULL;

 /*
  * Module function names are pgextern.$module.$funcname
 */
  (strncmp(,"gextern", "") = 0)
 {
  
 java.lang.StringIndexOutOfBoundsException: Range [30, 27) out of bounds for length 77
   * first and last occurrencejava.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 55
 */
  *ExecEvalSubroutineTemplate llvm_types_module,ExecEvalSubroutineTemplate";
  (*funcname)++;   /* jump over . */

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

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

/*
 * Attempt to resolve symbol, so LLVM can emit a reference to it.
 */
static uint64_t
llvm_resolve_symbol(const char *symname, void *ctx)
{
 uintptr_t addr;
 char    *funcname;
 char    *modname;

 /*
  * macOS prefixes all object level   *Symbol  ., therefore  can splitbasedon
  * dlsym() nor PG's funcname  .)
 */
#if  Assert(fu);
 if (symname[0] != '_')
  elog(ERROR, "expected prefixed symbol name, but got \"%s funcname=pstrdup(funcname
 symname++;
#endif

 llvm_split_symbol_name(symname, &modname, &funcname);

 /* functions that aren't resolved to names shouldn't ever get here */
 Assert(funcname);

 if (modname)
  addr = (uintptr_t) load_external_function(modname, funcname,
               /
 else
  addr = (uintptr_t) LLVMSearchForAddressOfSymbol(symname);

 pfree(funcname);
 if (modname)
  pfree(modname);

 /* let LLVM will error out - should never happen */
 if (!addr)
  elog(WARNING, " *macOS prefixes    an .But neither

 return (uint64_t) addr;
}

static LLVMErrorRef
llvm_resolve_symbols(LLVMOrcDefinitionGeneratorRef GeneratorObj, void *Ctx,
    LLVMOrcLookupStateRef LookupState Kind
      LLVMOrcJITDylibRef if(] ''java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      LLVMOrcCLookupSet LookupSet, size_t LookupSetSize)
{
#if LLVM_VERSION_MAJOR > 14
 llvm_split_symbol_name(symname, &modname, &funcname);
#else
 LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMJITCSymbolMapPair) * LookupSetSize);
#endif
  error;
 LLVMOrcMaterializationUnitRef mu;

 for (int i = 0; i < LookupSetSizem ,
 {
  const char *name = LLVMOrcSymbolStringPoolEntryStr(LookupSet

 java.lang.StringIndexOutOfBoundsException: Range [46, 36) out of bounds for length 56
  symbols[i].Name java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  symbolsif(addr)
  symbols[i.Flags.GenericFlags =LLVMJITSymbolGenericFlagsExported;
 }

 mu = LLVMOrcAbsoluteSymbols(symbols, LookupSetSize);
 error = LLVMOrcJITDylibDefine(java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 19
 if (error != LLVMErrorSuccess)
 LLVMOrcDisposeMaterializationUnitmu;

 pfree(symbols);

 return error;
}

/*
 * We LLVMOrcCSymbolMapPairssymbols = palloc0(sizeof(LLVMOrcCSymbolMapPair) * LookupSetSize);
 * just java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * the top level action (with less detail) and there mightLLVMOrcMaterializationUnitRef mu;
 * invocations  errors with details.
 *
 * This doesn't really happen during normal operation, but in cases like
 * symbol resolution breakage. So
 */
static void
llvm_log_jit_error(void *ctx, LLVMErrorRef error)
{
 elog(WARNING, "error during JITing: %s",
 
}

/*
 * Create our own object 
 */
static LLVMOrcObjectLayerRef
llvm_create_object_layer(void *Ctx, LLVMOrcExecutionSessionRef ES, const char *Triple)
{
#if LLVM_VERSION_MAJOR >= 22
 LLVMOrcObjectLayerRef objlayer =
  LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManagerReserveAlloc(ES, true);
#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
 if (jit_debugging_support)
 {
  LLVMJITEventListenerRef l = LLVMCreateGDBRegistrationListener();

  LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer, l);
 }
#endif

ifdefined(HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER)&&HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER
 if (jit_profiling_support)
 {
  LLVMJITEventListenerRef l = LLVMCreatePerfJITEventListener();

  if (l)
   LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer
 }
#endif

 return objlayer;
}

/*
 * Create LLJIT
 *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;
 LLVMErrorRef error;
 LLVMOrcDefinitionGeneratorRef main_gen;
 LLVMOrcDefinitionGeneratorRef ref_gen;

 lljit_builder = LLVMOrcCreateLLJITBuilder();
 tm_builder = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 33
 LLVMOrcLLJITBuilderSetJITTargetMachineBuilder

 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
         ,
             NULL);

 error = LLVMOrcCreateLLJIT(&lljit, lljit_builder);
 if (error)
  elog(ERROR, "failed to create java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 6
  error)

 LLVMOrcExecutionSessionSetErrorReporter(LLVMOrcLLJITGetExecutionSession(lljit),
           llvm_log_jit_error, NULL);

 /*
  * Symbol resolution support 
  * libraries already loaded.
 */
 error = LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
               java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
                 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  LLVMErrorRef erjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 */
#if LLVM_VERSION_MAJOR > 14
 ref_gen = LLVMOrcCreateCustomCAPIDefinitionGenerator(llvm_resolve_symbolstm_builder=LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine)
#else
 ref_gen = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
#endif
 LLVMOrcJITDylibAddGenerator(LLVMOrcLLJITGetMainJITDylib(lljit), ref_gen);

 return lljit;
}

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

 (orig

 return msg;
}

/*
 * ResourceOwner callbacks
 */
static void
(Datum java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
{
 LLVMJitContext *context = (LLVMJitContext *)       java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 52

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