llvmjit.c Source File (original) (raw)

16#include <llvm-c/Analysis.h>

17#include <llvm-c/BitReader.h>

18#include <llvm-c/BitWriter.h>

19#include <llvm-c/Core.h>

20#include <llvm-c/ExecutionEngine.h>

21#if LLVM_VERSION_MAJOR > 16

22#include <llvm-c/Transforms/PassBuilder.h>

23#endif

24#include <llvm-c/Orc.h>

25#include <llvm-c/OrcEE.h>

26#include <llvm-c/LLJIT.h>

27#include <llvm-c/Support.h>

28#include <llvm-c/Target.h>

29#if LLVM_VERSION_MAJOR < 17

30#include <llvm-c/Transforms/IPO.h>

31#include <llvm-c/Transforms/PassManagerBuilder.h>

32#include <llvm-c/Transforms/Scalar.h>

33#include <llvm-c/Transforms/Utils.h>

34#endif

45#define LLVMJIT_LLVM_CONTEXT_REUSE_MAX 100

49{

101

102

107static void llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef module);

108

113

116

117

119

121{

122 .name = "LLVM JIT context",

126 .DebugPrint = NULL

127};

128

129

130static inline void

132{

134}

135static inline void

137{

139}

140

142 .name = "llvmjit",

143 .version = PG_VERSION

144);

145

146

147

148

149

150void

152{

156}

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172static void

174{

176 elog(ERROR, "Trying to recreate a non-existing context");

177

178

179

180

181

183 {

185 return;

186 }

187

189 {

191 return;

192 }

193

194

195

196

197

198

199

201

205

206

207

208

209

210

212}

213

214

215

216

217

218

219

220

221

222LLVMJitContext *

224{

225 LLVMJitContext *context;

226

228

230

232

234

236 sizeof(LLVMJitContext));

237 context->base.flags = jitFlags;

238

239

242

244

245 return context;

246}

247

248

249

250

251static void

253{

254 LLVMJitContext *llvm_jit_context = (LLVMJitContext *) context;

256

257

258

259

260

262

263

264

265

266

267

269 return;

270

272

273 if (llvm_jit_context->module)

274 {

275 LLVMDisposeModule(llvm_jit_context->module);

276 llvm_jit_context->module = NULL;

277 }

278

279 foreach(lc, llvm_jit_context->handles)

280 {

282

283 {

284 LLVMOrcExecutionSessionRef ee;

285 LLVMOrcSymbolStringPoolRef sp;

286

289

290

291

292

293

294

295

296 ee = LLVMOrcLLJITGetExecutionSession(jit_handle->lljit);

297 sp = LLVMOrcExecutionSessionGetSymbolStringPool(ee);

298 LLVMOrcSymbolStringPoolClearDeadEntries(sp);

299 }

300

301 pfree(jit_handle);

302 }

303 list_free(llvm_jit_context->handles);

304 llvm_jit_context->handles = NIL;

305

307

308 if (llvm_jit_context->resowner)

310}

311

312

313

314

315LLVMModuleRef

317{

319

320

321

322

323 if (!context->module)

324 {

325 context->compiled = false;

327 context->module = LLVMModuleCreateWithNameInContext("pg", llvm_context);

328 LLVMSetTarget(context->module, llvm_triple);

329 LLVMSetDataLayout(context->module, llvm_layout);

330 }

331

332 return context->module;

333}

334

335

336

337

338

339

340char *

342{

343 Assert(context->module != NULL);

344

345 context->base.instr.created_functions++;

346

347

348

349

350

352 basename,

353 context->module_generation,

354 context->counter++);

355}

356

357

358

359

360

361void *

363{

365

367

368

369

370

371

372 if (!context->compiled)

373 {

375 }

376

377

378

379

380

381

382 foreach(lc, context->handles)

383 {

387 LLVMErrorRef error;

388 LLVMOrcJITTargetAddress addr;

389

391

392 addr = 0;

395 elog(ERROR, "failed to look up symbol \"%s\": %s",

397

398

399

400

401

402

403

406 endtime, starttime);

407

408 if (addr)

409 return (void *) (uintptr_t) addr;

410 }

411

413

414 return NULL;

415}

416

417

418

419

420

421LLVMTypeRef

423{

424 LLVMValueRef v_srcvar;

425 LLVMTypeRef typ;

426

427

429 if (!v_srcvar)

430 elog(ERROR, "variable %s not in llvmjit_types.c", varname);

431

432 typ = LLVMGlobalGetValueType(v_srcvar);

433

434 return typ;

435}

436

437

438

439

440

441LLVMTypeRef

443{

444 LLVMValueRef v_srcvar;

445 LLVMTypeRef typ;

446

448 if (!v_srcvar)

449 elog(ERROR, "function %s not in llvmjit_types.c", varname);

450

452

453 return typ;

454}

455

456

457

458

459

460

461

462

463LLVMValueRef

465{

466 LLVMValueRef v_srcfn;

467 LLVMValueRef v_fn;

468

469

470 v_fn = LLVMGetNamedFunction(mod, funcname);

471 if (v_fn)

472 return v_fn;

473

475

476 if (!v_srcfn)

478

479 v_fn = LLVMAddFunction(mod,

483

484 return v_fn;

485}

486

487

488

489

490

491static void

493{

494 int num_attributes;

495 LLVMAttributeRef *attrs;

496

497 num_attributes = LLVMGetAttributeCountAtIndex(v_from, index);

498

499 if (num_attributes == 0)

500 return;

501

502 attrs = palloc(sizeof(LLVMAttributeRef) * num_attributes);

503 LLVMGetAttributesAtIndex(v_from, index, attrs);

504

505 for (int attno = 0; attno < num_attributes; attno++)

506 LLVMAddAttributeAtIndex(v_to, index, attrs[attno]);

507

509}

510

511

512

513

514

515void

517{

519

520

522

524 {

525

527 }

528

529

530 param_count = LLVMCountParams(v_from);

531

532 for (int paramidx = 1; paramidx <= param_count; paramidx++)

534}

535

536

537

538

539LLVMValueRef

541 LLVMBuilderRef builder,

542 LLVMModuleRef mod,

544{

545 char *modname;

546 char *basename;

548

549 LLVMValueRef v_fn;

550

552

553 if (modname != NULL && basename != NULL)

554 {

555

557 }

558 else if (basename != NULL)

559 {

560

562 }

563 else

564 {

565

566

567

568

569

570 LLVMValueRef v_fn_addr;

571

574 v_fn = LLVMGetNamedGlobal(mod, funcname);

575 if (v_fn != 0)

577

579

581 LLVMSetInitializer(v_fn, v_fn_addr);

582 LLVMSetGlobalConstant(v_fn, true);

583 LLVMSetLinkage(v_fn, LLVMPrivateLinkage);

584 LLVMSetUnnamedAddr(v_fn, true);

585

587 }

588

589

590 v_fn = LLVMGetNamedFunction(mod, funcname);

591 if (v_fn != 0)

592 return v_fn;

593

595

596 return v_fn;

597}

598

599

600

601

602static void

604{

605#if LLVM_VERSION_MAJOR < 17

606 LLVMPassManagerBuilderRef llvm_pmb;

607 LLVMPassManagerRef llvm_mpm;

608 LLVMPassManagerRef llvm_fpm;

609 LLVMValueRef func;

610 int compile_optlevel;

611

612 if (context->base.flags & PGJIT_OPT3)

613 compile_optlevel = 3;

614 else

615 compile_optlevel = 0;

616

617

618

619

620

621

622 llvm_pmb = LLVMPassManagerBuilderCreate();

623 LLVMPassManagerBuilderSetOptLevel(llvm_pmb, compile_optlevel);

624 llvm_fpm = LLVMCreateFunctionPassManagerForModule(module);

625

626 if (context->base.flags & PGJIT_OPT3)

627 {

628

629 LLVMPassManagerBuilderUseInlinerWithThreshold(llvm_pmb, 512);

630 }

631 else

632 {

633

634 LLVMAddPromoteMemoryToRegisterPass(llvm_fpm);

635 }

636

637 LLVMPassManagerBuilderPopulateFunctionPassManager(llvm_pmb, llvm_fpm);

638

639

640

641

642

643 LLVMInitializeFunctionPassManager(llvm_fpm);

644 for (func = LLVMGetFirstFunction(context->module);

645 func != NULL;

646 func = LLVMGetNextFunction(func))

647 LLVMRunFunctionPassManager(llvm_fpm, func);

648 LLVMFinalizeFunctionPassManager(llvm_fpm);

649 LLVMDisposePassManager(llvm_fpm);

650

651

652

653

654

655 llvm_mpm = LLVMCreatePassManager();

656 LLVMPassManagerBuilderPopulateModulePassManager(llvm_pmb,

657 llvm_mpm);

658

659 if (!(context->base.flags & PGJIT_OPT3))

660 LLVMAddAlwaysInlinerPass(llvm_mpm);

661

663 && !(context->base.flags & PGJIT_OPT3))

664 LLVMAddFunctionInliningPass(llvm_mpm);

665 LLVMRunPassManager(llvm_mpm, context->module);

666 LLVMDisposePassManager(llvm_mpm);

667

668 LLVMPassManagerBuilderDispose(llvm_pmb);

669#else

670 LLVMPassBuilderOptionsRef options;

671 LLVMErrorRef err;

672 const char *passes;

673

674 if (context->base.flags & PGJIT_OPT3)

675 passes = "default";

676 else

677 passes = "default,mem2reg";

678

679 options = LLVMCreatePassBuilderOptions();

680

681#ifdef LLVM_PASS_DEBUG

682 LLVMPassBuilderOptionsSetDebugLogging(options, 1);

683#endif

684

685

686#ifdef USE_ASSERT_CHECKING

687 LLVMPassBuilderOptionsSetVerifyEach(options, true);

688#endif

689

690 LLVMPassBuilderOptionsSetInlinerThreshold(options, 512);

691

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

693

696

697 LLVMDisposePassBuilderOptions(options);

698#endif

699}

700

701

702

703

704static void

706{

711 LLVMOrcLLJITRef compile_orc;

712

713 if (context->base.flags & PGJIT_OPT3)

715 else

717

718

720 {

725 endtime, starttime);

726 }

727

729 {

731

734 context->module_generation);

735 LLVMWriteBitcodeToFile(context->module, filename);

737 }

738

739

740

745 endtime, starttime);

746

748 {

750

753 context->module_generation);

754 LLVMWriteBitcodeToFile(context->module, filename);

756 }

757

760

761

762

763

764

765

766

768 {

769 LLVMOrcThreadSafeModuleRef ts_module;

770 LLVMErrorRef error;

771 LLVMOrcJITDylibRef jd = LLVMOrcLLJITGetMainJITDylib(compile_orc);

772

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

774

775 handle->lljit = compile_orc;

776 handle->resource_tracker = LLVMOrcJITDylibCreateResourceTracker(jd);

777

778

779

780

781

782

783

784 context->module = NULL;

785 error = LLVMOrcLLJITAddLLVMIRModuleWithRT(compile_orc,

787 ts_module);

788

790 elog(ERROR, "failed to JIT module: %s",

792

793

794 }

795

798 endtime, starttime);

799

800 context->module = NULL;

801 context->compiled = true;

802

803

805 context->handles = lappend(context->handles, handle);

807

809 (errmsg_internal("time to inline: %.3fs, opt: %.3fs, emit: %.3fs",

815}

816

817

818

819

820static void

822{

824 char *error = NULL;

825 char *cpu = NULL;

826 char *features = NULL;

827 LLVMTargetMachineRef opt0_tm;

828 LLVMTargetMachineRef opt3_tm;

829

831 return;

832

834

835 LLVMInitializeNativeTarget();

836 LLVMInitializeNativeAsmPrinter();

837 LLVMInitializeNativeAsmParser();

838

840 {

842

845 }

846

847

848

849

850

852

853

854

855

857

859 {

861 }

862

863

864

865

866

867

868

869 cpu = LLVMGetHostCPUName();

870 features = LLVMGetHostCPUFeatures();

871 elog(DEBUG2, "LLVMJIT detected CPU \"%s\", with features \"%s\"",

872 cpu, features);

873

874 opt0_tm =

876 LLVMCodeGenLevelNone,

877 LLVMRelocDefault,

878 LLVMCodeModelJITDefault);

879 opt3_tm =

881 LLVMCodeGenLevelAggressive,

882 LLVMRelocDefault,

883 LLVMCodeModelJITDefault);

884

885 LLVMDisposeMessage(cpu);

886 cpu = NULL;

887 LLVMDisposeMessage(features);

888 features = NULL;

889

890

891 LLVMLoadLibraryPermanently(NULL);

892

893 {

895

897 opt0_tm = 0;

898

900 opt3_tm = 0;

901 }

902

904

906

908}

909

910static void

912{

913

914

915

916

917

918

919

920

922 {

924 return;

925 }

926

928 elog(PANIC, "LLVMJitContext in use count not 0 at exit (is %zu)",

930

931 {

933 {

936 }

938 {

941 }

943 {

946 }

947 }

948}

949

950

951static LLVMTypeRef

953{

954 LLVMValueRef value;

955 LLVMTypeRef typ;

956

957

958 value = LLVMGetNamedFunction(mod, name);

961

963

964 return typ;

965}

966

967

968

969

970

971static void

973{

975 elog(ERROR, "failed to extract target information, llvmjit_types.c not loaded");

976

979

982}

983

984

985

986

987

988

989

990static void

992{

994 LLVMMemoryBufferRef buf;

995 char *msg;

996

998

999

1000 if (LLVMCreateMemoryBufferWithContentsOfFile(path, &buf, &msg))

1001 {

1002 elog(ERROR, "LLVMCreateMemoryBufferWithContentsOfFile(%s) failed: %s",

1003 path, msg);

1004 }

1005

1006

1008 {

1009 elog(ERROR, "LLVMParseBitcodeInContext2 of %s failed", path);

1010 }

1011 LLVMDisposeMemoryBuffer(buf);

1012

1034

1038}

1039

1040

1041

1042

1043

1044void

1046{

1047 *modname = NULL;

1049

1050

1051

1052

1053 if (strncmp(name, "pgextern.", strlen("pgextern.")) == 0)

1054 {

1055

1056

1057

1058

1060 (*funcname)++;

1061

1062 *modname = pnstrdup(name + strlen("pgextern."),

1063 *funcname - name - strlen("pgextern.") - 1);

1065

1067 }

1068 else

1069 {

1070 *modname = NULL;

1072 }

1073}

1074

1075

1076

1077

1078static uint64_t

1080{

1081 uintptr_t addr;

1083 char *modname;

1084

1085

1086

1087

1088

1089#if defined(__darwin__)

1090 if (symname[0] != '_')

1091 elog(ERROR, "expected prefixed symbol name, but got \"%s\"", symname);

1092 symname++;

1093#endif

1094

1096

1097

1099

1100 if (modname)

1102 true, NULL);

1103 else

1104 addr = (uintptr_t) LLVMSearchForAddressOfSymbol(symname);

1105

1107 if (modname)

1109

1110

1111 if (!addr)

1112 elog(WARNING, "failed to resolve name %s", symname);

1113

1114 return (uint64_t) addr;

1115}

1116

1117static LLVMErrorRef

1119 LLVMOrcLookupStateRef *LookupState, LLVMOrcLookupKind Kind,

1120 LLVMOrcJITDylibRef JD, LLVMOrcJITDylibLookupFlags JDLookupFlags,

1121 LLVMOrcCLookupSet LookupSet, size_t LookupSetSize)

1122{

1123#if LLVM_VERSION_MAJOR > 14

1124 LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMOrcCSymbolMapPair) * LookupSetSize);

1125#else

1126 LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMJITCSymbolMapPair) * LookupSetSize);

1127#endif

1128 LLVMErrorRef error;

1129 LLVMOrcMaterializationUnitRef mu;

1130

1131 for (int i = 0; i < LookupSetSize; i++)

1132 {

1133 const char *name = LLVMOrcSymbolStringPoolEntryStr(LookupSet[i].Name);

1134

1135 LLVMOrcRetainSymbolStringPoolEntry(LookupSet[i].Name);

1136 symbols[i].Name = LookupSet[i].Name;

1138 symbols[i].Sym.Flags.GenericFlags = LLVMJITSymbolGenericFlagsExported;

1139 }

1140

1141 mu = LLVMOrcAbsoluteSymbols(symbols, LookupSetSize);

1142 error = LLVMOrcJITDylibDefine(JD, mu);

1143 if (error != LLVMErrorSuccess)

1144 LLVMOrcDisposeMaterializationUnit(mu);

1145

1147

1149}

1150

1151

1152

1153

1154

1155

1156

1157

1158

1159

1160static void

1162{

1163 elog(WARNING, "error during JITing: %s",

1165}

1166

1167

1168

1169

1170static LLVMOrcObjectLayerRef

1172{

1173#ifdef USE_LLVM_BACKPORT_SECTION_MEMORY_MANAGER

1174 LLVMOrcObjectLayerRef objlayer =

1175 LLVMOrcCreateRTDyldObjectLinkingLayerWithSafeSectionMemoryManager(ES);

1176#else

1177 LLVMOrcObjectLayerRef objlayer =

1178 LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(ES);

1179#endif

1180

1181

1182#if defined(HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER) && HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER

1184 {

1185 LLVMJITEventListenerRef l = LLVMCreateGDBRegistrationListener();

1186

1187 LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer, l);

1188 }

1189#endif

1190

1191#if defined(HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER) && HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER

1193 {

1194 LLVMJITEventListenerRef l = LLVMCreatePerfJITEventListener();

1195

1196 LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer, l);

1197 }

1198#endif

1199

1200 return objlayer;

1201}

1202

1203

1204

1205

1206

1207static LLVMOrcLLJITRef

1209{

1210 LLVMOrcLLJITRef lljit;

1211 LLVMOrcJITTargetMachineBuilderRef tm_builder;

1212 LLVMOrcLLJITBuilderRef lljit_builder;

1213 LLVMErrorRef error;

1214 LLVMOrcDefinitionGeneratorRef main_gen;

1215 LLVMOrcDefinitionGeneratorRef ref_gen;

1216

1217 lljit_builder = LLVMOrcCreateLLJITBuilder();

1218 tm_builder = LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(tm);

1219 LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(lljit_builder, tm_builder);

1220

1221 LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(lljit_builder,

1223 NULL);

1224

1225 error = LLVMOrcCreateLLJIT(&lljit, lljit_builder);

1227 elog(ERROR, "failed to create lljit instance: %s",

1229

1230 LLVMOrcExecutionSessionSetErrorReporter(LLVMOrcLLJITGetExecutionSession(lljit),

1232

1233

1234

1235

1236

1237 error = LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(&main_gen,

1238 LLVMOrcLLJITGetGlobalPrefix(lljit),

1239 0, NULL);

1241 elog(ERROR, "failed to create generator: %s",

1243 LLVMOrcJITDylibAddGenerator(LLVMOrcLLJITGetMainJITDylib(lljit), main_gen);

1244

1245

1246

1247

1248

1249#if LLVM_VERSION_MAJOR > 14

1250 ref_gen = LLVMOrcCreateCustomCAPIDefinitionGenerator(llvm_resolve_symbols, NULL, NULL);

1251#else

1252 ref_gen = LLVMOrcCreateCustomCAPIDefinitionGenerator(llvm_resolve_symbols, NULL);

1253#endif

1254 LLVMOrcJITDylibAddGenerator(LLVMOrcLLJITGetMainJITDylib(lljit), ref_gen);

1255

1256 return lljit;

1257}

1258

1259static char *

1261{

1262 char *orig = LLVMGetErrorMessage(error);

1263 char *msg = pstrdup(orig);

1264

1265 LLVMDisposeErrorMessage(orig);

1266

1267 return msg;

1268}

1269

1270

1271

1272

1273static void

1275{

1276 LLVMJitContext *context = (LLVMJitContext *) DatumGetPointer(res);

1277

1278 context->resowner = NULL;

1280}

void * load_external_function(const char *filename, const char *funcname, bool signalNotFound, void **filehandle)

int errmsg_internal(const char *fmt,...)

int errhidestmt(bool hide_stmt)

int errhidecontext(bool hide_ctx)

#define ereport(elevel,...)

void err(int eval, const char *fmt,...)

void fmgr_symbol(Oid functionId, char **mod, char **fn)

char pkglib_path[MAXPGPATH]

Assert(PointerIsAligned(start, uint64))

#define INSTR_TIME_SET_CURRENT(t)

#define INSTR_TIME_GET_DOUBLE(t)

#define INSTR_TIME_ACCUM_DIFF(x, y, z)

void on_proc_exit(pg_on_exit_callback function, Datum arg)

bool proc_exit_inprogress

void jit_release_context(JitContext *context)

bool jit_profiling_support

bool jit_debugging_support

List * lappend(List *list, void *datum)

void list_free(List *list)

LLVMTypeRef StructFunctionCallInfoData

LLVMTypeRef StructMinimalTupleData

LLVMTypeRef StructMinimalTupleTableSlot

LLVMTypeRef StructPlanState

static LLVMContextRef llvm_context

LLVMJitContext * llvm_create_context(int jitFlags)

LLVMTypeRef StructExprState

static LLVMOrcLLJITRef llvm_opt3_orc

static const char * llvm_triple

LLVMTypeRef StructExprEvalStep

LLVMValueRef llvm_pg_func(LLVMModuleRef mod, const char *funcname)

static void llvm_recreate_llvm_context(void)

struct LLVMJitHandle LLVMJitHandle

LLVMTypeRef TypeParamBool

LLVMTypeRef StructMemoryContextData

static void llvm_set_target(void)

static LLVMTargetRef llvm_targetref

static bool llvm_session_initialized

LLVMTypeRef StructAggStatePerGroupData

static void llvm_create_types(void)

LLVMTypeRef llvm_pg_var_type(const char *varname)

static void ResourceOwnerRememberJIT(ResourceOwner owner, LLVMJitContext *handle)

static void llvm_session_initialize(void)

static size_t llvm_jit_context_in_use_count

static const char * llvm_layout

LLVMValueRef llvm_function_reference(LLVMJitContext *context, LLVMBuilderRef builder, LLVMModuleRef mod, FunctionCallInfo fcinfo)

char * llvm_expand_funcname(struct LLVMJitContext *context, const char *basename)

static void ResOwnerReleaseJitContext(Datum res)

void llvm_split_symbol_name(const char *name, char **modname, char **funcname)

LLVMTypeRef llvm_pg_var_func_type(const char *varname)

LLVMTypeRef StructTupleTableSlot

LLVMTypeRef TypeStorageBool

static LLVMTypeRef load_return_type(LLVMModuleRef mod, const char *name)

static size_t llvm_generation

static LLVMOrcLLJITRef llvm_opt0_orc

static LLVMOrcObjectLayerRef llvm_create_object_layer(void *Ctx, LLVMOrcExecutionSessionRef ES, const char *Triple)

static void ResourceOwnerForgetJIT(ResourceOwner owner, LLVMJitContext *handle)

static void llvm_compile_module(LLVMJitContext *context)

LLVMTypeRef StructHeapTupleTableSlot

static char * llvm_error_message(LLVMErrorRef error)

static LLVMOrcLLJITRef llvm_create_jit_instance(LLVMTargetMachineRef tm)

static LLVMModuleRef llvm_types_module

static void llvm_shutdown(int code, Datum arg)

PG_MODULE_MAGIC_EXT(.name="llvmjit",.version=PG_VERSION)

static LLVMOrcThreadSafeContextRef llvm_ts_context

static const ResourceOwnerDesc jit_resowner_desc

#define LLVMJIT_LLVM_CONTEXT_REUSE_MAX

static LLVMErrorRef llvm_resolve_symbols(LLVMOrcDefinitionGeneratorRef GeneratorObj, void *Ctx, LLVMOrcLookupStateRef *LookupState, LLVMOrcLookupKind Kind, LLVMOrcJITDylibRef JD, LLVMOrcJITDylibLookupFlags JDLookupFlags, LLVMOrcCLookupSet LookupSet, size_t LookupSetSize)

static void llvm_copy_attributes_at_index(LLVMValueRef v_from, LLVMValueRef v_to, uint32 index)

LLVMModuleRef llvm_mutable_module(LLVMJitContext *context)

LLVMTypeRef StructAggState

LLVMTypeRef TypePGFunction

LLVMTypeRef StructTupleDescData

LLVMValueRef AttributeTemplate

static size_t llvm_llvm_context_reuse_count

LLVMTypeRef StructExprContext

static void llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef module)

static uint64_t llvm_resolve_symbol(const char *name, void *ctx)

LLVMTypeRef StructHeapTupleHeaderData

static void llvm_log_jit_error(void *ctx, LLVMErrorRef error)

LLVMTypeRef StructHeapTupleData

static void llvm_release_context(JitContext *context)

void * llvm_get_function(LLVMJitContext *context, const char *funcname)

LLVMTypeRef StructNullableDatum

LLVMValueRef ExecEvalSubroutineTemplate

LLVMValueRef ExecEvalBoolSubroutineTemplate

void _PG_jit_provider_init(JitProviderCallbacks *cb)

LLVMTypeRef StructAggStatePerTransData

void llvm_copy_attributes(LLVMValueRef v_from, LLVMValueRef v_to)

void llvm_enter_fatal_on_oom(void)

bool llvm_in_fatal_on_oom(void)

void llvm_assert_in_fatal_section(void)

void llvm_reset_after_error(void)

void llvm_leave_fatal_on_oom(void)

bool llvm_compile_expr(ExprState *state)

void llvm_inline(LLVMModuleRef M)

void llvm_inline_reset_caches(void)

LLVMTypeRef LLVMGetFunctionReturnType(LLVMValueRef r)

LLVMTypeRef LLVMGetFunctionType(LLVMValueRef r)

void * MemoryContextAlloc(MemoryContext context, Size size)

void * MemoryContextAllocZero(MemoryContext context, Size size)

char * pstrdup(const char *in)

void pfree(void *pointer)

void * palloc0(Size size)

MemoryContext TopMemoryContext

char * pnstrdup(const char *in, Size len)

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

static Datum PointerGetDatum(const void *X)

static Pointer DatumGetPointer(Datum X)

char * psprintf(const char *fmt,...)

ResourceOwner CurrentResourceOwner

void ResourceOwnerForget(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)

void ResourceOwnerRemember(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)

void ResourceOwnerEnlarge(ResourceOwner owner)

#define RELEASE_PRIO_JIT_CONTEXTS

@ RESOURCE_RELEASE_BEFORE_LOCKS

JitProviderCompileExprCB compile_expr

JitProviderResetAfterErrorCB reset_after_error

JitProviderReleaseContextCB release_context

LLVMOrcResourceTrackerRef resource_tracker