PostgreSQL Source Code  git master
llvmjit_inline.cpp File Reference
#include "postgres.h"
#include "jit/llvmjit.h"
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "common/string.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include <llvm-c/Core.h>
#include <llvm-c/BitReader.h>
#include <llvm/ADT/SetVector.h>
#include <llvm/ADT/StringSet.h>
#include <llvm/ADT/StringMap.h>
#include <llvm/Analysis/ModuleSummaryAnalysis.h>
#include <llvm/Bitcode/ReaderWriter.h>
#include <llvm/Support/Error.h>
#include <llvm/IR/Attributes.h>
#include <llvm/IR/DebugInfo.h>
#include <llvm/IR/IntrinsicInst.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/ModuleSummaryIndex.h>
#include <llvm/Linker/IRMover.h>
#include <llvm/Support/ManagedStatic.h>
Include dependency graph for llvmjit_inline.cpp:

Go to the source code of this file.

Data Structures

struct  InlineWorkListItem
 
struct  FunctionInlineState
 

Macros

#define ilog(...)   (void) 0
 
#define IRMOVE_PARAMS
 
#define hasFnAttr   hasFnAttribute
 

Typedefs

typedef llvm::SmallVector< llvm::ModuleSummaryIndex *, 2 > InlineSearchPath
 
typedef struct InlineWorkListItem InlineWorkListItem
 
typedef llvm::SmallVector< InlineWorkListItem, 128 > InlineWorkList
 
typedef struct FunctionInlineState FunctionInlineState
 
typedef llvm::StringMap< FunctionInlineStateFunctionInlineStates
 
typedef llvm::StringMap< llvm::StringSet<> > ImportMapTy
 
typedef llvm::StringMap< std::unique_ptr< llvm::Module > > ModuleCache
 
typedef llvm::StringMap< std::unique_ptr< llvm::ModuleSummaryIndex > > SummaryCache
 

Functions

static std::unique_ptr< ImportMapTyllvm_build_inline_plan (llvm::Module *mod)
 
static void llvm_execute_inline_plan (llvm::Module *mod, ImportMapTy *globalsToInline)
 
static llvm::Module * load_module_cached (llvm::StringRef modPath)
 
static std::unique_ptr< llvm::Module > load_module (llvm::StringRef Identifier)
 
static std::unique_ptr< llvm::ModuleSummaryIndex > llvm_load_summary (llvm::StringRef path)
 
static llvm::Function * create_redirection_function (std::unique_ptr< llvm::Module > &importMod, llvm::Function *F, llvm::StringRef Name)
 
static bool function_inlinable (llvm::Function &F, int threshold, FunctionInlineStates &functionState, InlineWorkList &worklist, InlineSearchPath &searchpath, llvm::SmallPtrSet< const llvm::Function *, 8 > &visitedFunctions, int &running_instcount, llvm::StringSet<> &importVars)
 
static void function_references (llvm::Function &F, int &running_instcount, llvm::SmallPtrSet< llvm::GlobalVariable *, 8 > &referencedVars, llvm::SmallPtrSet< llvm::Function *, 8 > &referencedFunctions)
 
static void add_module_to_inline_search_path (InlineSearchPath &path, llvm::StringRef modpath)
 
static llvm::SmallVector< llvm::GlobalValueSummary *, 1 > summaries_for_guid (const InlineSearchPath &path, llvm::GlobalValue::GUID guid)
 
void llvm_inline (LLVMModuleRef M)
 

Variables

const float inline_cost_decay_factor = 0.5
 
const int inline_initial_cost = 150
 
llvm::ManagedStatic< ModuleCachemodule_cache
 
llvm::ManagedStatic< SummaryCachesummary_cache
 

Macro Definition Documentation

◆ hasFnAttr

#define hasFnAttr   hasFnAttribute

◆ ilog

#define ilog (   ...)    (void) 0

Definition at line 151 of file llvmjit_inline.cpp.

◆ IRMOVE_PARAMS

#define IRMOVE_PARAMS

Typedef Documentation

◆ FunctionInlineState

◆ FunctionInlineStates

typedef llvm::StringMap<FunctionInlineState> FunctionInlineStates

Definition at line 94 of file llvmjit_inline.cpp.

◆ ImportMapTy

typedef llvm::StringMap<llvm::StringSet<> > ImportMapTy

Definition at line 100 of file llvmjit_inline.cpp.

◆ InlineSearchPath

typedef llvm::SmallVector<llvm::ModuleSummaryIndex *, 2> InlineSearchPath

Definition at line 71 of file llvmjit_inline.cpp.

◆ InlineWorkList

typedef llvm::SmallVector<InlineWorkListItem, 128> InlineWorkList

Definition at line 81 of file llvmjit_inline.cpp.

◆ InlineWorkListItem

◆ ModuleCache

typedef llvm::StringMap<std::unique_ptr<llvm::Module> > ModuleCache

Definition at line 110 of file llvmjit_inline.cpp.

◆ SummaryCache

typedef llvm::StringMap<std::unique_ptr<llvm::ModuleSummaryIndex> > SummaryCache

Definition at line 112 of file llvmjit_inline.cpp.

Function Documentation

◆ add_module_to_inline_search_path()

static void add_module_to_inline_search_path ( InlineSearchPath path,
llvm::StringRef  modpath 
)
static

Definition at line 807 of file llvmjit_inline.cpp.

808 {
809  /* only extension in libdir are candidates for inlining for now */
810  if (!modpath.startswith("$libdir/"))
811  return;
812 
813  /* if there's no match, attempt to load */
814  auto it = summary_cache->find(modpath);
815  if (it == summary_cache->end())
816  {
817  std::string path(modpath);
818  path = path.replace(0, strlen("$libdir"), std::string(pkglib_path) + "/bitcode");
819  path += ".index.bc";
820  (*summary_cache)[modpath] = llvm_load_summary(path);
821  it = summary_cache->find(modpath);
822  }
823 
824  Assert(it != summary_cache->end());
825 
826  /* if the entry isn't NULL, it's validly loaded */
827  if (it->second)
828  searchpath.push_back(it->second.get());
829 }
char pkglib_path[MAXPGPATH]
Definition: globals.c:76
Assert(fmt[strlen(fmt) - 1] !='\n')
static std::unique_ptr< llvm::ModuleSummaryIndex > llvm_load_summary(llvm::StringRef path)
llvm::ManagedStatic< SummaryCache > summary_cache
char string[11]
Definition: preproc-type.c:46

References Assert(), llvm_load_summary(), pkglib_path, and summary_cache.

Referenced by llvm_build_inline_plan().

◆ create_redirection_function()

static llvm::Function * create_redirection_function ( std::unique_ptr< llvm::Module > &  importMod,
llvm::Function *  F,
llvm::StringRef  Name 
)
static

Definition at line 867 of file llvmjit_inline.cpp.

870 {
871  typedef llvm::GlobalValue::LinkageTypes LinkageTypes;
872 
873  llvm::LLVMContext &Context = F->getContext();
874  llvm::IRBuilder<> Builder(Context);
875  llvm::Function *AF;
876  llvm::BasicBlock *BB;
877  llvm::CallInst *fwdcall;
878 #if LLVM_VERSION_MAJOR < 14
879  llvm::Attribute inlineAttribute;
880 #endif
881 
882  AF = llvm::Function::Create(F->getFunctionType(),
883  LinkageTypes::AvailableExternallyLinkage,
884  Name, importMod.get());
885  BB = llvm::BasicBlock::Create(Context, "entry", AF);
886 
887  Builder.SetInsertPoint(BB);
888  fwdcall = Builder.CreateCall(F, &*AF->arg_begin());
889 #if LLVM_VERSION_MAJOR < 14
890  inlineAttribute = llvm::Attribute::get(Context,
891  llvm::Attribute::AlwaysInline);
892  fwdcall->addAttribute(~0U, inlineAttribute);
893 #else
894  fwdcall->addFnAttr(llvm::Attribute::AlwaysInline);
895 #endif
896  Builder.CreateRet(fwdcall);
897 
898  return AF;
899 }
#define F(X, Y, Z)
Definition: md5.c:60
Definition: c.h:676

References F.

Referenced by llvm_execute_inline_plan().

◆ function_inlinable()

static bool function_inlinable ( llvm::Function &  F,
int  threshold,
FunctionInlineStates functionState,
InlineWorkList worklist,
InlineSearchPath searchpath,
llvm::SmallPtrSet< const llvm::Function *, 8 > &  visitedFunctions,
int &  running_instcount,
llvm::StringSet<> &  importVars 
)
static

Definition at line 568 of file llvmjit_inline.cpp.

576 {
577  int subThreshold = threshold * inline_cost_decay_factor;
578  llvm::SmallPtrSet<llvm::GlobalVariable *, 8> referencedVars;
579  llvm::SmallPtrSet<llvm::Function *, 8> referencedFunctions;
580 
581  /* can't rely on what may be inlined */
582  if (F.isInterposable())
583  return false;
584 
585  /*
586  * Can't rely on function being present. Alternatively we could create a
587  * static version of these functions?
588  */
589  if (F.hasAvailableExternallyLinkage())
590  return false;
591 
592  ilog(DEBUG1, "checking inlinability of %s", F.getName().data());
593 
594  if (F.materialize())
595  elog(FATAL, "failed to materialize metadata");
596 
597 #if LLVM_VERSION_MAJOR < 14
598 #define hasFnAttr hasFnAttribute
599 #endif
600 
601  if (F.getAttributes().hasFnAttr(llvm::Attribute::NoInline))
602  {
603  ilog(DEBUG1, "ineligibile to import %s due to noinline",
604  F.getName().data());
605  return false;
606  }
607 
608  function_references(F, running_instcount, referencedVars, referencedFunctions);
609 
610  for (llvm::GlobalVariable* rv: referencedVars)
611  {
612  if (rv->materialize())
613  elog(FATAL, "failed to materialize metadata");
614 
615  /*
616  * Don't inline functions that access thread local variables. That
617  * doesn't work on current LLVM releases (but might in future).
618  */
619  if (rv->isThreadLocal())
620  {
621  ilog(DEBUG1, "cannot inline %s due to thread-local variable %s",
622  F.getName().data(), rv->getName().data());
623  return false;
624  }
625 
626  /*
627  * Never want to inline externally visible vars, cheap enough to
628  * reference.
629  */
630  if (rv->hasExternalLinkage() || rv->hasAvailableExternallyLinkage())
631  continue;
632 
633  /*
634  * If variable is file-local, we need to inline it, to be able to
635  * inline the function itself. Can't do that if the variable can be
636  * modified, because they'd obviously get out of sync.
637  *
638  * XXX: Currently not a problem, but there'd be problems with
639  * nontrivial initializers if they were allowed for postgres.
640  */
641  if (!rv->isConstant())
642  {
643  ilog(DEBUG1, "cannot inline %s due to uncloneable variable %s",
644  F.getName().data(), rv->getName().data());
645  return false;
646  }
647 
648  ilog(DEBUG1, "memorizing global var %s linkage %d for inlining",
649  rv->getName().data(), (int)rv->getLinkage());
650 
651  importVars.insert(rv->getName());
652  /* small cost attributed to each cloned global */
653  running_instcount += 5;
654  }
655 
656  visitedFunctions.insert(&F);
657 
658  /*
659  * Check referenced functions. Check whether used static ones are
660  * inlinable, and remember external ones for inlining.
661  */
662  for (llvm::Function* referencedFunction: referencedFunctions)
663  {
664  llvm::StringSet<> recImportVars;
665 
666  if (referencedFunction->materialize())
667  elog(FATAL, "failed to materialize metadata");
668 
669  if (referencedFunction->isIntrinsic())
670  continue;
671 
672  /* if already visited skip, otherwise remember */
673  if (!visitedFunctions.insert(referencedFunction).second)
674  continue;
675 
676  /*
677  * We don't inline external functions directly here, instead we put
678  * them on the worklist if appropriate and check them from
679  * llvm_build_inline_plan().
680  */
681  if (referencedFunction->hasExternalLinkage())
682  {
683  llvm::StringRef funcName = referencedFunction->getName();
684 
685  /*
686  * Don't bother checking for inlining if remaining cost budget is
687  * very small.
688  */
689  if (subThreshold < 5)
690  continue;
691 
692  auto it = functionStates.find(funcName);
693  if (it == functionStates.end())
694  {
695  FunctionInlineState inlineState;
696 
697  inlineState.costLimit = subThreshold;
698  inlineState.processed = false;
699  inlineState.inlined = false;
700  inlineState.allowReconsidering = false;
701 
702  functionStates[funcName] = inlineState;
703  worklist.push_back({funcName, searchpath});
704 
705  ilog(DEBUG1,
706  "considering extern function %s at %d for inlining",
707  funcName.data(), subThreshold);
708  }
709  else if (!it->second.inlined &&
710  (!it->second.processed || it->second.allowReconsidering) &&
711  it->second.costLimit < subThreshold)
712  {
713  /*
714  * Update inlining threshold if higher. Need to re-queue
715  * to be processed if already processed with lower
716  * threshold.
717  */
718  if (it->second.processed)
719  {
720  ilog(DEBUG1,
721  "reconsidering extern function %s at %d for inlining, increasing from %d",
722  funcName.data(), subThreshold, it->second.costLimit);
723 
724  it->second.processed = false;
725  it->second.allowReconsidering = false;
726  worklist.push_back({funcName, searchpath});
727  }
728  it->second.costLimit = subThreshold;
729  }
730  continue;
731  }
732 
733  /* can't rely on what may be inlined */
734  if (referencedFunction->isInterposable())
735  return false;
736 
737  if (!function_inlinable(*referencedFunction,
738  subThreshold,
739  functionStates,
740  worklist,
741  searchpath,
742  visitedFunctions,
743  running_instcount,
744  recImportVars))
745  {
746  ilog(DEBUG1,
747  "cannot inline %s due to required function %s not being inlinable",
748  F.getName().data(), referencedFunction->getName().data());
749  return false;
750  }
751 
752  /* import referenced function itself */
753  importVars.insert(referencedFunction->getName());
754 
755  /* import referenced function and its dependants */
756  for (auto& recImportVar : recImportVars)
757  importVars.insert(recImportVar.first());
758  }
759 
760  return true;
761 }
#define FATAL
Definition: elog.h:35
#define DEBUG1
Definition: elog.h:24
#define elog(elevel,...)
Definition: elog.h:218
const float inline_cost_decay_factor
static void function_references(llvm::Function &F, int &running_instcount, llvm::SmallPtrSet< llvm::GlobalVariable *, 8 > &referencedVars, llvm::SmallPtrSet< llvm::Function *, 8 > &referencedFunctions)
#define ilog(...)
static bool function_inlinable(llvm::Function &F, int threshold, FunctionInlineStates &functionState, InlineWorkList &worklist, InlineSearchPath &searchpath, llvm::SmallPtrSet< const llvm::Function *, 8 > &visitedFunctions, int &running_instcount, llvm::StringSet<> &importVars)

References FunctionInlineState::allowReconsidering, FunctionInlineState::costLimit, DEBUG1, elog, F, FATAL, function_references(), ilog, inline_cost_decay_factor, FunctionInlineState::inlined, and FunctionInlineState::processed.

Referenced by llvm_build_inline_plan().

◆ function_references()

static void function_references ( llvm::Function &  F,
int &  running_instcount,
llvm::SmallPtrSet< llvm::GlobalVariable *, 8 > &  referencedVars,
llvm::SmallPtrSet< llvm::Function *, 8 > &  referencedFunctions 
)
static

Definition at line 511 of file llvmjit_inline.cpp.

515 {
516  llvm::SmallPtrSet<const llvm::User *, 32> Visited;
517 
518  for (llvm::BasicBlock &BB : F)
519  {
520  for (llvm::Instruction &I : BB)
521  {
522  if (llvm::isa<llvm::DbgInfoIntrinsic>(I))
523  continue;
524 
525  llvm::SmallVector<llvm::User *, 8> Worklist;
526  Worklist.push_back(&I);
527 
528  running_instcount++;
529 
530  while (!Worklist.empty()) {
531  llvm::User *U = Worklist.pop_back_val();
532 
533  /* visited before */
534  if (!Visited.insert(U).second)
535  continue;
536 
537  for (auto &OI : U->operands()) {
538  llvm::User *Operand = llvm::dyn_cast<llvm::User>(OI);
539  if (!Operand)
540  continue;
541  if (llvm::isa<llvm::BlockAddress>(Operand))
542  continue;
543  if (auto *GV = llvm::dyn_cast<llvm::GlobalVariable>(Operand)) {
544  referencedVars.insert(GV);
545  if (GV->hasInitializer())
546  Worklist.push_back(GV->getInitializer());
547  continue;
548  }
549  if (auto *CF = llvm::dyn_cast<llvm::Function>(Operand)) {
550  referencedFunctions.insert(CF);
551  continue;
552  }
553  Worklist.push_back(Operand);
554  }
555  }
556  }
557  }
558 }
#define I(X, Y, Z)
Definition: md5.c:63

References F, and I.

Referenced by function_inlinable().

◆ llvm_build_inline_plan()

static std::unique_ptr< ImportMapTy > llvm_build_inline_plan ( llvm::Module *  mod)
static

Definition at line 174 of file llvmjit_inline.cpp.

175 {
176  std::unique_ptr<ImportMapTy> globalsToInline(new ImportMapTy());
177  FunctionInlineStates functionStates;
178  InlineWorkList worklist;
179 
180  InlineSearchPath defaultSearchPath;
181 
182  /* attempt to add module to search path */
183  add_module_to_inline_search_path(defaultSearchPath, "$libdir/postgres");
184  /* if postgres isn't available, no point continuing */
185  if (defaultSearchPath.empty())
186  return nullptr;
187 
188  /*
189  * Start inlining with current references to external functions by putting
190  * them on the inlining worklist. If, during inlining of those, new extern
191  * functions need to be inlined, they'll also be put there, with a lower
192  * priority.
193  */
194  for (const llvm::Function &funcDecl : mod->functions())
195  {
196  InlineWorkListItem item = {};
197  FunctionInlineState inlineState = {};
198 
199  /* already has a definition */
200  if (!funcDecl.isDeclaration())
201  continue;
202 
203  /* llvm provides implementation */
204  if (funcDecl.isIntrinsic())
205  continue;
206 
207  item.symbolName = funcDecl.getName();
208  item.searchpath = defaultSearchPath;
209  worklist.push_back(item);
210  inlineState.costLimit = inline_initial_cost;
211  inlineState.processed = false;
212  inlineState.inlined = false;
213  inlineState.allowReconsidering = false;
214  functionStates[funcDecl.getName()] = inlineState;
215  }
216 
217  /*
218  * Iterate over pending worklist items, look them up in index, check
219  * whether they should be inlined.
220  */
221  while (!worklist.empty())
222  {
223  InlineWorkListItem item = worklist.pop_back_val();
224  llvm::StringRef symbolName = item.symbolName;
225  char *cmodname;
226  char *cfuncname;
227  FunctionInlineState &inlineState = functionStates[symbolName];
228  llvm::GlobalValue::GUID funcGUID;
229 
230  llvm_split_symbol_name(symbolName.data(), &cmodname, &cfuncname);
231 
232  funcGUID = llvm::GlobalValue::getGUID(cfuncname);
233 
234  /* already processed */
235  if (inlineState.processed)
236  continue;
237 
238 
239  if (cmodname)
241 
242  /*
243  * Iterate over all known definitions of function, via the index. Then
244  * look up module(s), check if function actually is defined (there
245  * could be hash conflicts).
246  */
247  for (const auto &gvs : summaries_for_guid(item.searchpath, funcGUID))
248  {
249  const llvm::FunctionSummary *fs;
250  llvm::StringRef modPath = gvs->modulePath();
251  llvm::Module *defMod;
252  llvm::Function *funcDef;
253 
254  fs = llvm::cast<llvm::FunctionSummary>(gvs);
255 
256 #if LLVM_VERSION_MAJOR > 3
257  if (gvs->notEligibleToImport())
258  {
259  ilog(DEBUG1, "ineligibile to import %s due to summary",
260  symbolName.data());
261  continue;
262  }
263 #endif
264 
265  if ((int) fs->instCount() > inlineState.costLimit)
266  {
267  ilog(DEBUG1, "ineligibile to import %s due to early threshold: %u vs %u",
268  symbolName.data(), fs->instCount(), inlineState.costLimit);
269  inlineState.allowReconsidering = true;
270  continue;
271  }
272 
273  defMod = load_module_cached(modPath);
274  if (defMod->materializeMetadata())
275  elog(FATAL, "failed to materialize metadata");
276 
277  funcDef = defMod->getFunction(cfuncname);
278 
279  /*
280  * This can happen e.g. in case of a hash collision of the
281  * function's name.
282  */
283  if (!funcDef)
284  continue;
285 
286  if (funcDef->materialize())
287  elog(FATAL, "failed to materialize metadata");
288 
289  Assert(!funcDef->isDeclaration());
290  Assert(funcDef->hasExternalLinkage());
291 
292  llvm::StringSet<> importVars;
293  llvm::SmallPtrSet<const llvm::Function *, 8> visitedFunctions;
294  int running_instcount = 0;
295 
296  /*
297  * Check whether function, and objects it depends on, are
298  * inlinable.
299  */
300  if (function_inlinable(*funcDef,
301  inlineState.costLimit,
302  functionStates,
303  worklist,
304  item.searchpath,
305  visitedFunctions,
306  running_instcount,
307  importVars))
308  {
309  /*
310  * Check whether function and all its dependencies are too
311  * big. Dependencies already counted for other functions that
312  * will get inlined are not counted again. While this make
313  * things somewhat order dependent, I can't quite see a point
314  * in a different behaviour.
315  */
316  if (running_instcount > inlineState.costLimit)
317  {
318  ilog(DEBUG1, "skipping inlining of %s due to late threshold %d vs %d",
319  symbolName.data(), running_instcount, inlineState.costLimit);
320  inlineState.allowReconsidering = true;
321  continue;
322  }
323 
324  ilog(DEBUG1, "inline top function %s total_instcount: %d, partial: %d",
325  symbolName.data(), running_instcount, fs->instCount());
326 
327  /* import referenced function itself */
328  importVars.insert(symbolName);
329 
330  {
331  llvm::StringSet<> &modGlobalsToInline = (*globalsToInline)[modPath];
332  for (auto& importVar : importVars)
333  modGlobalsToInline.insert(importVar.first());
334  Assert(modGlobalsToInline.size() > 0);
335  }
336 
337  /* mark function as inlined */
338  inlineState.inlined = true;
339 
340  /*
341  * Found definition to inline, don't look for further
342  * potential definitions.
343  */
344  break;
345  }
346  else
347  {
348  ilog(DEBUG1, "had to skip inlining %s",
349  symbolName.data());
350 
351  /* It's possible there's another definition that's inlinable. */
352  }
353  }
354 
355  /*
356  * Signal that we're done with symbol, whether successful (inlined =
357  * true above) or not.
358  */
359  inlineState.processed = true;
360  }
361 
362  return globalsToInline;
363 }
void llvm_split_symbol_name(const char *name, char **modname, char **funcname)
Definition: llvmjit.c:1035
llvm::SmallVector< InlineWorkListItem, 128 > InlineWorkList
const int inline_initial_cost
llvm::SmallVector< llvm::ModuleSummaryIndex *, 2 > InlineSearchPath
static llvm::Module * load_module_cached(llvm::StringRef modPath)
static llvm::SmallVector< llvm::GlobalValueSummary *, 1 > summaries_for_guid(const InlineSearchPath &path, llvm::GlobalValue::GUID guid)
llvm::StringMap< llvm::StringSet<> > ImportMapTy
static void add_module_to_inline_search_path(InlineSearchPath &path, llvm::StringRef modpath)
llvm::StringMap< FunctionInlineState > FunctionInlineStates
llvm::StringRef symbolName
llvm::SmallVector< llvm::ModuleSummaryIndex *, 2 > searchpath

References add_module_to_inline_search_path(), FunctionInlineState::allowReconsidering, Assert(), FunctionInlineState::costLimit, DEBUG1, elog, FATAL, function_inlinable(), ilog, inline_initial_cost, FunctionInlineState::inlined, llvm_split_symbol_name(), load_module_cached(), FunctionInlineState::processed, InlineWorkListItem::searchpath, summaries_for_guid(), and InlineWorkListItem::symbolName.

Referenced by llvm_inline().

◆ llvm_execute_inline_plan()

static void llvm_execute_inline_plan ( llvm::Module *  mod,
ImportMapTy globalsToInline 
)
static

Definition at line 370 of file llvmjit_inline.cpp.

371 {
372  llvm::IRMover Mover(*mod);
373 
374  for (const auto& toInline : *globalsToInline)
375  {
376  const llvm::StringRef& modPath = toInline.first();
377  const llvm::StringSet<>& modGlobalsToInline = toInline.second;
378  llvm::SetVector<llvm::GlobalValue *> GlobalsToImport;
379 
380  Assert(module_cache->count(modPath));
381  std::unique_ptr<llvm::Module> importMod(std::move((*module_cache)[modPath]));
382  module_cache->erase(modPath);
383 
384  if (modGlobalsToInline.empty())
385  continue;
386 
387  for (auto &glob: modGlobalsToInline)
388  {
389  llvm::StringRef SymbolName = glob.first();
390  char *modname;
391  char *funcname;
392 
393  llvm_split_symbol_name(SymbolName.data(), &modname, &funcname);
394 
395  llvm::GlobalValue *valueToImport = importMod->getNamedValue(funcname);
396 
397  if (!valueToImport)
398  elog(FATAL, "didn't refind value %s to import", SymbolName.data());
399 
400  /*
401  * For functions (global vars are only inlined if already static),
402  * mark imported variables as being clones from other
403  * functions. That a) avoids symbol conflicts b) allows the
404  * optimizer to perform inlining.
405  */
406  if (llvm::isa<llvm::Function>(valueToImport))
407  {
408  llvm::Function *F = llvm::dyn_cast<llvm::Function>(valueToImport);
409  typedef llvm::GlobalValue::LinkageTypes LinkageTypes;
410 
411  /*
412  * Per-function info isn't necessarily stripped yet, as the
413  * module is lazy-loaded when stripped above.
414  */
415  llvm::stripDebugInfo(*F);
416 
417  /*
418  * If the to-be-imported function is one referenced including
419  * its module name, create a tiny inline function that just
420  * forwards the call. One might think a GlobalAlias would do
421  * the trick, but a) IRMover doesn't override a declaration
422  * with an alias pointing to a definition (instead renaming
423  * it), b) Aliases can't be AvailableExternally.
424  */
425  if (modname)
426  {
427  llvm::Function *AF;
428 
429  AF = create_redirection_function(importMod, F, SymbolName);
430 
431  GlobalsToImport.insert(AF);
432  llvm::stripDebugInfo(*AF);
433  }
434 
435  if (valueToImport->hasExternalLinkage())
436  {
437  valueToImport->setLinkage(LinkageTypes::AvailableExternallyLinkage);
438  }
439  }
440 
441  GlobalsToImport.insert(valueToImport);
442  ilog(DEBUG1, "performing import of %s %s",
443  modPath.data(), SymbolName.data());
444 
445  }
446 
447 #if LLVM_VERSION_MAJOR > 4
448 #define IRMOVE_PARAMS , /*IsPerformingImport=*/false
449 #elif LLVM_VERSION_MAJOR > 3
450 #define IRMOVE_PARAMS , /*LinkModuleInlineAsm=*/false, /*IsPerformingImport=*/false
451 #else
452 #define IRMOVE_PARAMS
453 #endif
454  if (Mover.move(std::move(importMod), GlobalsToImport.getArrayRef(),
455  [](llvm::GlobalValue &, llvm::IRMover::ValueAdder) {}
456  IRMOVE_PARAMS))
457  elog(FATAL, "function import failed with linker error");
458  }
459 }
static llvm::Function * create_redirection_function(std::unique_ptr< llvm::Module > &importMod, llvm::Function *F, llvm::StringRef Name)
llvm::ManagedStatic< ModuleCache > module_cache
#define IRMOVE_PARAMS

References Assert(), create_redirection_function(), DEBUG1, elog, F, FATAL, ilog, IRMOVE_PARAMS, llvm_split_symbol_name(), and module_cache.

Referenced by llvm_inline().

◆ llvm_inline()

void llvm_inline ( LLVMModuleRef  M)

Definition at line 159 of file llvmjit_inline.cpp.

160 {
161  llvm::Module *mod = llvm::unwrap(M);
162 
163  std::unique_ptr<ImportMapTy> globalsToInline = llvm_build_inline_plan(mod);
164  if (!globalsToInline)
165  return;
166  llvm_execute_inline_plan(mod, globalsToInline.get());
167 }
static std::unique_ptr< ImportMapTy > llvm_build_inline_plan(llvm::Module *mod)
static void llvm_execute_inline_plan(llvm::Module *mod, ImportMapTy *globalsToInline)

References llvm_build_inline_plan(), and llvm_execute_inline_plan().

Referenced by llvm_compile_module().

◆ llvm_load_summary()

static std::unique_ptr< llvm::ModuleSummaryIndex > llvm_load_summary ( llvm::StringRef  path)
static

Definition at line 768 of file llvmjit_inline.cpp.

769 {
770  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer> > MBOrErr =
771  llvm::MemoryBuffer::getFile(path);
772 
773  if (std::error_code EC = MBOrErr.getError())
774  {
775  ilog(DEBUG1, "failed to open %s: %s", path.data(),
776  EC.message().c_str());
777  }
778  else
779  {
780  llvm::MemoryBufferRef ref(*MBOrErr.get().get());
781 
782 #if LLVM_VERSION_MAJOR > 3
783  llvm::Expected<std::unique_ptr<llvm::ModuleSummaryIndex> > IndexOrErr =
784  llvm::getModuleSummaryIndex(ref);
785  if (IndexOrErr)
786  return std::move(IndexOrErr.get());
787  elog(FATAL, "failed to load summary \"%s\": %s",
788  path.data(),
789  toString(IndexOrErr.takeError()).c_str());
790 #else
791  llvm::ErrorOr<std::unique_ptr<llvm::ModuleSummaryIndex> > IndexOrErr =
792  llvm::getModuleSummaryIndex(ref, [](const llvm::DiagnosticInfo &) {});
793  if (IndexOrErr)
794  return std::move(IndexOrErr.get());
795  elog(FATAL, "failed to load summary \"%s\": %s",
796  path.data(),
797  IndexOrErr.getError().message().c_str());
798 #endif
799  }
800  return nullptr;
801 }

References DEBUG1, elog, FATAL, and ilog.

Referenced by add_module_to_inline_search_path().

◆ load_module()

static std::unique_ptr< llvm::Module > load_module ( llvm::StringRef  Identifier)
static

Definition at line 481 of file llvmjit_inline.cpp.

482 {
483  LLVMMemoryBufferRef buf;
484  LLVMModuleRef mod;
485  char path[MAXPGPATH];
486  char *msg;
487 
488  snprintf(path, MAXPGPATH,"%s/bitcode/%s", pkglib_path, Identifier.data());
489 
490  if (LLVMCreateMemoryBufferWithContentsOfFile(path, &buf, &msg))
491  elog(FATAL, "failed to open bitcode file \"%s\": %s",
492  path, msg);
493  if (LLVMGetBitcodeModuleInContext2(LLVMGetGlobalContext(), buf, &mod))
494  elog(FATAL, "failed to parse bitcode in file \"%s\"", path);
495 
496  /*
497  * Currently there's no use in more detailed debug info for JITed
498  * code. Until that changes, not much point in wasting memory and cycles
499  * on processing debuginfo.
500  */
501  llvm::StripDebugInfo(*llvm::unwrap(mod));
502 
503  return std::unique_ptr<llvm::Module>(llvm::unwrap(mod));
504 }
#define MAXPGPATH
static char * buf
Definition: pg_test_fsync.c:70
#define snprintf
Definition: port.h:222

References buf, elog, FATAL, MAXPGPATH, pkglib_path, and snprintf.

Referenced by load_module_cached().

◆ load_module_cached()

static llvm::Module * load_module_cached ( llvm::StringRef  modPath)
static

Definition at line 468 of file llvmjit_inline.cpp.

469 {
470  auto it = module_cache->find(modPath);
471  if (it == module_cache->end())
472  {
473  it = module_cache->insert(
474  std::make_pair(modPath, load_module(modPath))).first;
475  }
476 
477  return it->second.get();
478 }
static std::unique_ptr< llvm::Module > load_module(llvm::StringRef Identifier)

References load_module(), and module_cache.

Referenced by llvm_build_inline_plan().

◆ summaries_for_guid()

static llvm::SmallVector< llvm::GlobalValueSummary *, 1 > summaries_for_guid ( const InlineSearchPath path,
llvm::GlobalValue::GUID  guid 
)
static

Definition at line 836 of file llvmjit_inline.cpp.

837 {
838  llvm::SmallVector<llvm::GlobalValueSummary *, 1> matches;
839 
840  for (auto index : path)
841  {
842 #if LLVM_VERSION_MAJOR > 4
843  llvm::ValueInfo funcVI = index->getValueInfo(guid);
844 
845  /* if index doesn't know function, we don't have a body, continue */
846  if (funcVI)
847  for (auto &gv : funcVI.getSummaryList())
848  matches.push_back(gv.get());
849 #else
850  const llvm::const_gvsummary_iterator &I =
851  index->findGlobalValueSummaryList(guid);
852  if (I != index->end())
853  {
854  for (auto &gv : I->second)
855  matches.push_back(gv.get());
856  }
857 #endif
858  }
859 
860  return matches;
861 }
Definition: type.h:90

References I.

Referenced by llvm_build_inline_plan().

Variable Documentation

◆ inline_cost_decay_factor

const float inline_cost_decay_factor = 0.5

Definition at line 103 of file llvmjit_inline.cpp.

Referenced by function_inlinable().

◆ inline_initial_cost

const int inline_initial_cost = 150

Definition at line 104 of file llvmjit_inline.cpp.

Referenced by llvm_build_inline_plan().

◆ module_cache

llvm::ManagedStatic<ModuleCache> module_cache

Definition at line 111 of file llvmjit_inline.cpp.

Referenced by llvm_execute_inline_plan(), and load_module_cached().

◆ summary_cache

llvm::ManagedStatic<SummaryCache> summary_cache

Definition at line 113 of file llvmjit_inline.cpp.

Referenced by add_module_to_inline_search_path().