FunctionImport.cpp File Reference

#include "llvm/Transforms/IPO/FunctionImport.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Bitcode/BitcodeReader.h"
#include "llvm/IR/AutoUpgrade.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/GlobalObject.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/Linker/IRMover.h"
#include "llvm/ProfileData/PGOCtxProfReader.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/JSON.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/IPO/Internalize.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/FunctionImportUtils.h"
#include "llvm/Transforms/Utils/ValueMapper.h"
#include <cassert>
#include <memory>
#include <string>
#include <system_error>
#include <tuple>
#include <utility>

Go to the source code of this file.

Classes
class	GlobalsImporter
	Import globals referenced by a function or other globals that are being imported, if importing such global is possible. More...
class	ModuleImportsManager
	Determine the list of imports and exports for each module. More...
class	WorkloadImportsManager
	A ModuleImportsManager that operates based on a workload definition (see -thinlto-workload-def). More...
struct	ImportStatistics

Namespaces
namespace	llvm
	This is an optimization pass for GlobalISel generic memory operations.

Macros
#define	DEBUG_TYPE   "function-import"

Functions
	STATISTIC (NumImportedFunctionsThinLink, "Number of functions thin link decided to import")
	STATISTIC (NumImportedHotFunctionsThinLink, "Number of hot functions thin link decided to import")
	STATISTIC (NumImportedCriticalFunctionsThinLink, "Number of critical functions thin link decided to import")
	STATISTIC (NumImportedGlobalVarsThinLink, "Number of global variables thin link decided to import")
	STATISTIC (NumImportedFunctions, "Number of functions imported in backend")
	STATISTIC (NumImportedGlobalVars, "Number of global variables imported in backend")
	STATISTIC (NumImportedModules, "Number of modules imported from")
	STATISTIC (NumDeadSymbols, "Number of dead stripped symbols in index")
	STATISTIC (NumLiveSymbols, "Number of live symbols in index")
static std::unique_ptr< Module >	loadFile (const std::string &FileName, LLVMContext &Context)
static bool	shouldSkipLocalInAnotherModule (const GlobalValueSummary *RefSummary, size_t NumDefs, StringRef ImporterModule)
static auto	qualifyCalleeCandidates (const ModuleSummaryIndex &Index, ArrayRef< std::unique_ptr< GlobalValueSummary > > CalleeSummaryList, StringRef CallerModulePath)
	Given a list of possible callee implementation for a call site, qualify the legality of importing each.
static const GlobalValueSummary *	selectCallee (const ModuleSummaryIndex &Index, ArrayRef< std::unique_ptr< GlobalValueSummary > > CalleeSummaryList, unsigned Threshold, StringRef CallerModulePath, const GlobalValueSummary *&TooLargeOrNoInlineSummary, FunctionImporter::ImportFailureReason &Reason)
	Given a list of possible callee implementation for a call site, select one that fits the Threshold for function definition import.
static const char *	getFailureName (FunctionImporter::ImportFailureReason Reason)
static void	computeImportForFunction (const FunctionSummary &Summary, const ModuleSummaryIndex &Index, const unsigned Threshold, const GVSummaryMapTy &DefinedGVSummaries, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, SmallVectorImpl< EdgeInfo > &Worklist, GlobalsImporter &GVImporter, FunctionImporter::ImportMapTy &ImportList, DenseMap< StringRef, FunctionImporter::ExportSetTy > *ExportLists, FunctionImporter::ImportThresholdsTy &ImportThresholds)
	Compute the list of functions to import for a given caller.
static bool	isGlobalVarSummary (const ModuleSummaryIndex &Index, ValueInfo VI)
static bool	isGlobalVarSummary (const ModuleSummaryIndex &Index, GlobalValue::GUID G)
static unsigned	numGlobalVarSummaries (const ModuleSummaryIndex &Index, FunctionImporter::ExportSetTy &ExportSet)
static DenseMap< StringRef, ImportStatistics >	collectImportStatistics (const ModuleSummaryIndex &Index, const FunctionImporter::ImportMapTy &ImportList)
static bool	checkVariableImport (const ModuleSummaryIndex &Index, FunctionImporter::ImportListsTy &ImportLists, DenseMap< StringRef, FunctionImporter::ExportSetTy > &ExportLists)
static void	dumpImportListForModule (const ModuleSummaryIndex &Index, StringRef ModulePath, FunctionImporter::ImportMapTy &ImportList)
static void	ComputeCrossModuleImportForModuleForTest (StringRef ModulePath, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, const ModuleSummaryIndex &Index, FunctionImporter::ImportMapTy &ImportList)
	Compute all the imports for the given module using the Index.
static void	ComputeCrossModuleImportForModuleFromIndexForTest (StringRef ModulePath, const ModuleSummaryIndex &Index, FunctionImporter::ImportMapTy &ImportList)
	Mark all external summaries in Index for import into the given module.
void	updateValueInfoForIndirectCalls (ModuleSummaryIndex &Index, FunctionSummary *FS)
static Function *	replaceAliasWithAliasee (Module *SrcModule, GlobalAlias *GA)
	Make alias a clone of its aliasee.
static void	internalizeGVsAfterImport (Module &M)
static bool	doImportingForModuleForTest (Module &M, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing)

Variables
static cl::opt< unsigned >	ImportInstrLimit ("import-instr-limit", cl::init(100), cl::Hidden, cl::value_desc("N"), cl::desc("Only import functions with less than N instructions"))
	Limit on instruction count of imported functions.
static cl::opt< int >	ImportCutoff ("import-cutoff", cl::init(-1), cl::Hidden, cl::value_desc("N"), cl::desc("Only import first N functions if N>=0 (default -1)"))
static cl::opt< bool >	ForceImportAll ("force-import-all", cl::init(false), cl::Hidden, cl::desc("Import functions with noinline attribute"))
static cl::opt< float >	ImportInstrFactor ("import-instr-evolution-factor", cl::init(0.7), cl::Hidden, cl::value_desc("x"), cl::desc("As we import functions, multiply the " "`import-instr-limit` threshold by this factor " "before processing newly imported functions"))
static cl::opt< float >	ImportHotInstrFactor ("import-hot-evolution-factor", cl::init(1.0), cl::Hidden, cl::value_desc("x"), cl::desc("As we import functions called from hot callsite, multiply the " "`import-instr-limit` threshold by this factor " "before processing newly imported functions"))
static cl::opt< float >	ImportHotMultiplier ("import-hot-multiplier", cl::init(10.0), cl::Hidden, cl::value_desc("x"), cl::desc("Multiply the `import-instr-limit` threshold for hot callsites"))
static cl::opt< float >	ImportCriticalMultiplier ("import-critical-multiplier", cl::init(100.0), cl::Hidden, cl::value_desc("x"), cl::desc("Multiply the `import-instr-limit` threshold for critical callsites"))
static cl::opt< float >	ImportColdMultiplier ("import-cold-multiplier", cl::init(0), cl::Hidden, cl::value_desc("N"), cl::desc("Multiply the `import-instr-limit` threshold for cold callsites"))
static cl::opt< bool >	PrintImports ("print-imports", cl::init(false), cl::Hidden, cl::desc("Print imported functions"))
static cl::opt< bool >	PrintImportFailures ("print-import-failures", cl::init(false), cl::Hidden, cl::desc("Print information for functions rejected for importing"))
static cl::opt< bool >	ComputeDead ("compute-dead", cl::init(true), cl::Hidden, cl::desc("Compute dead symbols"))
static cl::opt< bool >	EnableImportMetadata ("enable-import-metadata", cl::init(false), cl::Hidden, cl::desc("Enable import metadata like 'thinlto_src_module' and " "'thinlto_src_file'"))
static cl::opt< std::string >	SummaryFile ("summary-file", cl::desc("The summary file to use for function importing."))
	Summary file to use for function importing when using -function-import from the command line.
static cl::opt< bool >	ImportAllIndex ("import-all-index", cl::desc("Import all external functions in index."))
	Used when testing importing from distributed indexes via opt.
static cl::opt< bool >	ImportDeclaration ("import-declaration", cl::init(false), cl::Hidden, cl::desc("If true, import function declaration as fallback if the function " "definition is not imported."))
	This is a test-only option.
static cl::opt< std::string >	WorkloadDefinitions ("thinlto-workload-def", cl::desc("Pass a workload definition. This is a file containing a JSON " "dictionary. The keys are root functions, the values are lists of " "functions to import in the module defining the root. It is " "assumed -funique-internal-linkage-names was used, to ensure " "local linkage functions have unique names. For example: \n" "{\n" " \"rootFunction_1\": [\"function_to_import_1\", " "\"function_to_import_2\"], \n" " \"rootFunction_2\": [\"function_to_import_3\", " "\"function_to_import_4\"] \n" "}"), cl::Hidden)
	Pass a workload description file - an example of workload would be the functions executed to satisfy a RPC request.
cl::opt< std::string >	UseCtxProfile

Macro Definition Documentation

DEBUG_TYPE

#define DEBUG_TYPE   "function-import"

Definition at line 56 of file FunctionImport.cpp.

Function Documentation

checkVariableImport()

static bool checkVariableImport ( const ModuleSummaryIndex &  Index, FunctionImporter::ImportListsTy &  ImportLists, DenseMap< StringRef, FunctionImporter::ExportSetTy > &  ExportLists  )

static

Definition at line 1138 of file FunctionImport.cpp.

References llvm::GlobalValue::AvailableExternallyLinkage, llvm::detail::DenseSetImpl< ValueT, MapTy, ValueInfoT >::count(), llvm::detail::DenseSetImpl< ValueT, MapTy, ValueInfoT >::insert(), llvm::GlobalValue::LinkOnceODRLinkage, and llvm::GlobalValue::WeakODRLinkage.

Referenced by llvm::ComputeCrossModuleImport().

collectImportStatistics()

static DenseMap< StringRef, ImportStatistics > collectImportStatistics ( const ModuleSummaryIndex &  Index, const FunctionImporter::ImportMapTy &  ImportList  )

static

Definition at line 1121 of file FunctionImport.cpp.

References llvm::GlobalValueSummary::Definition, and isGlobalVarSummary().

Referenced by llvm::ComputeCrossModuleImport(), and dumpImportListForModule().

ComputeCrossModuleImportForModuleForTest()

static void ComputeCrossModuleImportForModuleForTest ( StringRef  ModulePath, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)>  isPrevailing, const ModuleSummaryIndex &  Index, FunctionImporter::ImportMapTy &  ImportList  )

static

Compute all the imports for the given module using the Index.

isPrevailing is a callback that will be called with a global value's GUID and summary and should return whether the module corresponding to the summary contains the linker-prevailing copy of that value.

ImportList will be populated with a map that can be passed to FunctionImporter::importFunctions() above (see description there).

Definition at line 1300 of file FunctionImport.cpp.

References ModuleImportsManager::create(), llvm::dbgs(), dumpImportListForModule(), and LLVM_DEBUG.

Referenced by doImportingForModuleForTest().

ComputeCrossModuleImportForModuleFromIndexForTest()

static void ComputeCrossModuleImportForModuleFromIndexForTest ( StringRef  ModulePath, const ModuleSummaryIndex &  Index, FunctionImporter::ImportMapTy &  ImportList  )

static

Mark all external summaries in Index for import into the given module.

Used for testing the case of distributed builds using a distributed index.

ImportList will be populated with a map that can be passed to FunctionImporter::importFunctions() above (see description there).

Definition at line 1326 of file FunctionImport.cpp.

References llvm::FunctionImporter::ImportMapTy::addGUID(), assert(), and dumpImportListForModule().

Referenced by doImportingForModuleForTest().

computeImportForFunction()

static void computeImportForFunction ( const FunctionSummary &  Summary, const ModuleSummaryIndex &  Index, const unsigned  Threshold, const GVSummaryMapTy &  DefinedGVSummaries, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)>  isPrevailing, SmallVectorImpl< EdgeInfo > &  Worklist, GlobalsImporter &  GVImporter, FunctionImporter::ImportMapTy &  ImportList, DenseMap< StringRef, FunctionImporter::ExportSetTy > *  ExportLists, FunctionImporter::ImportThresholdsTy &  ImportThresholds  )

static

Compute the list of functions to import for a given caller.

Mark these imported functions and the symbols they reference in their source module as exported from their source module.

Definition at line 833 of file FunctionImport.cpp.

References llvm::FunctionImporter::ImportMapTy::addDefinition(), llvm::FunctionSummary::FFlags::AlwaysInline, assert(), llvm::CalleeInfo::Cold, llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::count(), llvm::CalleeInfo::Critical, llvm::dbgs(), llvm::SmallVectorImpl< T >::emplace_back(), llvm::errs(), llvm::FunctionSummary::fflags(), ForceImportAll, getFailureName(), llvm::CalleeInfo::Hot, ImportColdMultiplier, ImportCriticalMultiplier, ImportCutoff, ImportDeclaration, ImportHotInstrFactor, ImportHotMultiplier, ImportInstrFactor, llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::insert(), llvm::FunctionSummary::instCount(), IT, LLVM_DEBUG, llvm::logAllUnhandledErrors(), llvm::make_error_code(), llvm::FunctionImporter::ImportMapTy::maybeAddDeclaration(), llvm::GlobalValueSummary::modulePath(), llvm::FunctionImporter::ImportMapTy::NoChange, llvm::not_supported, GlobalsImporter::onImportingSummary(), PrintImportFailures, and selectCallee().

Referenced by ModuleImportsManager::computeImportForModule().

doImportingForModuleForTest()

static bool doImportingForModuleForTest ( Module &  M, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)>  isPrevailing  )

static

Definition at line 1989 of file FunctionImport.cpp.

References ComputeCrossModuleImportForModuleForTest(), ComputeCrossModuleImportForModuleFromIndexForTest(), llvm::errs(), llvm::GlobalValue::ExternalLinkage, llvm::getModuleSummaryIndexForFile(), I, ImportAllIndex, llvm::FunctionImporter::importFunctions(), llvm::GlobalValue::isLocalLinkage(), loadFile(), llvm::logAllUnhandledErrors(), llvm::renameModuleForThinLTO(), llvm::report_fatal_error(), SummaryFile, and llvm::Expected< T >::takeError().

Referenced by llvm::FunctionImportPass::run().

dumpImportListForModule()

static void dumpImportListForModule ( const ModuleSummaryIndex &  Index, StringRef  ModulePath, FunctionImporter::ImportMapTy &  ImportList  )

static

Definition at line 1273 of file FunctionImport.cpp.

References collectImportStatistics(), llvm::dbgs(), LLVM_DEBUG, llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::size(), and Stats.

Referenced by ComputeCrossModuleImportForModuleForTest(), and ComputeCrossModuleImportForModuleFromIndexForTest().

getFailureName()

static const char * getFailureName ( FunctionImporter::ImportFailureReason  Reason )

static

Definition at line 808 of file FunctionImport.cpp.

References llvm::FunctionImporter::GlobalVar, llvm::FunctionImporter::InterposableLinkage, llvm_unreachable, llvm::FunctionImporter::LocalLinkageNotInModule, llvm::FunctionImporter::NoInline, llvm::FunctionImporter::None, llvm::FunctionImporter::NotEligible, llvm::FunctionImporter::NotLive, and llvm::FunctionImporter::TooLarge.

Referenced by computeImportForFunction(), and ModuleImportsManager::computeImportForModule().

internalizeGVsAfterImport()

static void internalizeGVsAfterImport ( Module &  M )

static

Definition at line 1806 of file FunctionImport.cpp.

References llvm::GlobalValue::DefaultVisibility, and llvm::GlobalValue::InternalLinkage.

Referenced by llvm::FunctionImporter::importFunctions().

isGlobalVarSummary() [1/2]

static bool isGlobalVarSummary ( const ModuleSummaryIndex &  Index, GlobalValue::GUID  G  )

static

Definition at line 1095 of file FunctionImport.cpp.

References G, and isGlobalVarSummary().

isGlobalVarSummary() [2/2]

static bool isGlobalVarSummary ( const ModuleSummaryIndex &  Index, ValueInfo  VI  )

static

Definition at line 1088 of file FunctionImport.cpp.

References llvm::GlobalValueSummary::GlobalVarKind.

Referenced by collectImportStatistics(), isGlobalVarSummary(), and numGlobalVarSummaries().

loadFile()

static std::unique_ptr< Module > loadFile ( const std::string &  FileName, LLVMContext &  Context  )

static

Definition at line 183 of file FunctionImport.cpp.

References llvm::dbgs(), llvm::errs(), llvm::getLazyIRFileModule(), LLVM_DEBUG, and llvm::report_fatal_error().

Referenced by doImportingForModuleForTest().

numGlobalVarSummaries()

static unsigned numGlobalVarSummaries ( const ModuleSummaryIndex &  Index, FunctionImporter::ExportSetTy &  ExportSet  )

static

Definition at line 1104 of file FunctionImport.cpp.

References isGlobalVarSummary().

Referenced by llvm::ComputeCrossModuleImport().

qualifyCalleeCandidates()

static auto qualifyCalleeCandidates ( const ModuleSummaryIndex &  Index, ArrayRef< std::unique_ptr< GlobalValueSummary > >  CalleeSummaryList, StringRef  CallerModulePath  )

static

Given a list of possible callee implementation for a call site, qualify the legality of importing each.

The return is a range of pairs. Each pair corresponds to a candidate. The first value is the ImportFailureReason for that candidate, the second is the candidate.

Definition at line 220 of file FunctionImport.cpp.

References if(), llvm::GlobalValue::isInterposableLinkage(), llvm::map_range(), and shouldSkipLocalInAnotherModule().

Referenced by selectCallee().

replaceAliasWithAliasee()

static Function * replaceAliasWithAliasee ( Module *  SrcModule, GlobalAlias *  GA  )

static

Make alias a clone of its aliasee.

Definition at line 1790 of file FunctionImport.cpp.

References llvm::CloneFunction(), llvm::GlobalAlias::getAliaseeObject(), llvm::GlobalValue::getLinkage(), llvm::GlobalValue::getVisibility(), llvm::Value::replaceAllUsesWith(), llvm::GlobalValue::setLinkage(), llvm::GlobalValue::setVisibility(), and llvm::Value::takeName().

Referenced by llvm::FunctionImporter::importFunctions().

selectCallee()

static const GlobalValueSummary * selectCallee ( const ModuleSummaryIndex &  Index, ArrayRef< std::unique_ptr< GlobalValueSummary > >  CalleeSummaryList, unsigned  Threshold, StringRef  CallerModulePath, const GlobalValueSummary *&  TooLargeOrNoInlineSummary, FunctionImporter::ImportFailureReason &  Reason  )

static

Given a list of possible callee implementation for a call site, select one that fits the Threshold for function definition import.

If none are found, the Reason will give the last reason for the failure (last, in the order of CalleeSummaryList entries). While looking for a callee definition, sets TooLargeOrNoInlineSummary to the last seen too-large or noinline candidate; other modules may want to know the function summary or declaration even if a definition is not needed.

FIXME: select "best" instead of first that fits. But what is "best"?

• The smallest: more likely to be inlined.
• The one with the least outgoing edges (already well optimized).
• One from a module already being imported from in order to reduce the number of source modules parsed/linked.
• One that has PGO data attached.
• [insert you fancy metric here]

Definition at line 292 of file FunctionImport.cpp.

References ForceImportAll, and qualifyCalleeCandidates().

Referenced by computeImportForFunction().

shouldSkipLocalInAnotherModule()

static bool shouldSkipLocalInAnotherModule ( const GlobalValueSummary *  RefSummary, size_t  NumDefs, StringRef  ImporterModule  )

static

Definition at line 200 of file FunctionImport.cpp.

References llvm::GlobalValue::isLocalLinkage(), llvm::GlobalValueSummary::linkage(), and llvm::GlobalValueSummary::modulePath().

Referenced by qualifyCalleeCandidates().

STATISTIC() [1/9]

STATISTIC	(	NumDeadSymbols	,
		"Number of dead stripped symbols in index"
	)

STATISTIC() [2/9]

STATISTIC	(	NumImportedCriticalFunctionsThinLink	,
		"Number of critical functions thin link decided to import"
	)

STATISTIC() [3/9]

STATISTIC	(	NumImportedFunctions	,
		"Number of functions imported in backend"
	)

STATISTIC() [4/9]

STATISTIC	(	NumImportedFunctionsThinLink	,
		"Number of functions thin link decided to import"
	)

STATISTIC() [5/9]

STATISTIC	(	NumImportedGlobalVars	,
		"Number of global variables imported in backend"
	)

STATISTIC() [6/9]

STATISTIC	(	NumImportedGlobalVarsThinLink	,
		"Number of global variables thin link decided to import"
	)

STATISTIC() [7/9]

STATISTIC	(	NumImportedHotFunctionsThinLink	,
		"Number of hot functions thin link decided to import"
	)

STATISTIC() [8/9]

STATISTIC	(	NumImportedModules	,
		"Number of modules imported from"
	)

STATISTIC() [9/9]

STATISTIC	(	NumLiveSymbols	,
		"Number of live symbols in index"
	)

updateValueInfoForIndirectCalls()

void updateValueInfoForIndirectCalls	(	ModuleSummaryIndex &	Index,
		FunctionSummary *	FS
	)

Definition at line 1354 of file FunctionImport.cpp.

References llvm::any_of().

Referenced by llvm::computeDeadSymbolsAndUpdateIndirectCalls(), and llvm::updateIndirectCalls().

Variable Documentation

ComputeDead

cl::opt< bool > ComputeDead("compute-dead", cl::init(true), cl::Hidden, cl::desc("Compute dead symbols")) ( "compute-dead"  , cl::init(true)  , cl::Hidden  , cl::desc("Compute dead symbols")    )

static

Referenced by llvm::computeDeadSymbolsAndUpdateIndirectCalls().

EnableImportMetadata

cl::opt< bool > EnableImportMetadata("enable-import-metadata", cl::init(false), cl::Hidden, cl::desc("Enable import metadata like 'thinlto_src_module' and " "'thinlto_src_file'")) ( "enable-import-metadata"  , cl::init(false)  , cl::Hidden  , cl::desc("Enable import metadata like 'thinlto_src_module' and " "'thinlto_src_file'")    )

static

Referenced by llvm::FunctionImporter::importFunctions().

ForceImportAll

cl::opt< bool > ForceImportAll("force-import-all", cl::init(false), cl::Hidden, cl::desc("Import functions with noinline attribute")) ( "force-import-all"  , cl::init(false)  , cl::Hidden  , cl::desc("Import functions with noinline attribute")    )

static

Referenced by computeImportForFunction(), and selectCallee().

ImportAllIndex

cl::opt< bool > ImportAllIndex("import-all-index", cl::desc("Import all external functions in index.")) ( "import-all-index"  , cl::desc("Import all external functions in index.")    )

static

Used when testing importing from distributed indexes via opt.

Referenced by doImportingForModuleForTest().

ImportColdMultiplier

cl::opt< float > ImportColdMultiplier("import-cold-multiplier", cl::init(0), cl::Hidden, cl::value_desc("N"), cl::desc("Multiply the `import-instr-limit` threshold for cold callsites")) ( "import-cold-multiplier"  , cl::init(0)  , cl::Hidden  , cl::value_desc("N")  , cl::desc("Multiply the `import-instr-limit` threshold for cold callsites")    )

static

Referenced by computeImportForFunction().

ImportCriticalMultiplier

cl::opt< float > ImportCriticalMultiplier("import-critical-multiplier", cl::init(100.0), cl::Hidden, cl::value_desc("x"), cl::desc( "Multiply the `import-instr-limit` threshold for critical callsites")) ( "import-critical-multiplier"  , cl::init(100.0)  , cl::Hidden  , cl::value_desc("x")  , cl::desc( "Multiply the `import-instr-limit` threshold for critical callsites")    )

static

Referenced by computeImportForFunction().

ImportCutoff

cl::opt< int > ImportCutoff("import-cutoff", cl::init(-1), cl::Hidden, cl::value_desc("N"), cl::desc("Only import first N functions if N>=0 (default -1)")) ( "import-cutoff"  , cl::init(-1)  , cl::Hidden  , cl::value_desc("N")  , cl::desc("Only import first N functions if N>=0 (default -1)")    )

static

Referenced by computeImportForFunction().

ImportDeclaration

cl::opt< bool > ImportDeclaration("import-declaration", cl::init(false), cl::Hidden, cl::desc("If true, import function declaration as fallback if the function " "definition is not imported.")) ( "import-declaration"  , cl::init(false)  , cl::Hidden  , cl::desc("If true, import function declaration as fallback if the function " "definition is not imported.")    )

static

This is a test-only option.

If this option is enabled, the ThinLTO indexing step will import each function declaration as a fallback. In a real build this may increase ram usage of the indexing step unnecessarily. TODO: Implement selective import (based on combined summary analysis) to ensure the imported function has a use case in the postlink pipeline.

Referenced by computeImportForFunction().

ImportHotInstrFactor

cl::opt< float > ImportHotInstrFactor("import-hot-evolution-factor", cl::init(1.0), cl::Hidden, cl::value_desc("x"), cl::desc("As we import functions called from hot callsite, multiply the " "`import-instr-limit` threshold by this factor " "before processing newly imported functions")) ( "import-hot-evolution-factor"  , cl::init(1.0)  , cl::Hidden  , cl::value_desc("x")  , cl::desc("As we import functions called from hot callsite, multiply the " "`import-instr-limit` threshold by this factor " "before processing newly imported functions")    )

static

Referenced by computeImportForFunction().

ImportHotMultiplier

cl::opt< float > ImportHotMultiplier("import-hot-multiplier", cl::init(10.0), cl::Hidden, cl::value_desc("x"), cl::desc("Multiply the `import-instr-limit` threshold for hot callsites")) ( "import-hot-multiplier"  , cl::init(10.0)  , cl::Hidden  , cl::value_desc("x")  , cl::desc("Multiply the `import-instr-limit` threshold for hot callsites")    )

static

Referenced by computeImportForFunction().

ImportInstrFactor

cl::opt< float > ImportInstrFactor("import-instr-evolution-factor", cl::init(0.7), cl::Hidden, cl::value_desc("x"), cl::desc("As we import functions, multiply the " "`import-instr-limit` threshold by this factor " "before processing newly imported functions")) ( "import-instr-evolution-factor"  , cl::init(0.7)  , cl::Hidden  , cl::value_desc("x")  , cl::desc("As we import functions, multiply the " "`import-instr-limit` threshold by this factor " "before processing newly imported functions")    )

static

Referenced by computeImportForFunction().

ImportInstrLimit

cl::opt< unsigned > ImportInstrLimit("import-instr-limit", cl::init(100), cl::Hidden, cl::value_desc("N"), cl::desc("Only import functions with less than N instructions")) ( "import-instr-limit"  , cl::init(100)  , cl::Hidden  , cl::value_desc("N")  , cl::desc("Only import functions with less than N instructions")    )

static

Limit on instruction count of imported functions.

Referenced by ModuleImportsManager::computeImportForModule().

PrintImportFailures

cl::opt< bool > PrintImportFailures("print-import-failures", cl::init(false), cl::Hidden, cl::desc("Print information for functions rejected for importing")) ( "print-import-failures"  , cl::init(false)  , cl::Hidden  , cl::desc("Print information for functions rejected for importing")    )

static

Referenced by computeImportForFunction(), and ModuleImportsManager::computeImportForModule().

PrintImports

cl::opt< bool > PrintImports("print-imports", cl::init(false), cl::Hidden, cl::desc("Print imported functions")) ( "print-imports"  , cl::init(false)  , cl::Hidden  , cl::desc("Print imported functions")    )

static

Referenced by llvm::FunctionImporter::importFunctions().

SummaryFile

cl::opt< std::string > SummaryFile("summary-file", cl::desc("The summary file to use for function importing.")) ( "summary-file"  , cl::desc("The summary file to use for function importing.")    )

static

Summary file to use for function importing when using -function-import from the command line.

Referenced by doImportingForModuleForTest().

UseCtxProfile

cl::opt<std::string> UseCtxProfile

extern

WorkloadDefinitions

cl::opt< std::string > WorkloadDefinitions("thinlto-workload-def", cl::desc("Pass a workload definition. This is a file containing a JSON " "dictionary. The keys are root functions, the values are lists of " "functions to import in the module defining the root. It is " "assumed -funique-internal-linkage-names was used, to ensure " "local linkage functions have unique names. For example: \n" "{\n" " \"rootFunction_1\": [\"function_to_import_1\", " "\"function_to_import_2\"], \n" " \"rootFunction_2\": [\"function_to_import_3\", " "\"function_to_import_4\"] \n" "}"), cl::Hidden) ( "thinlto-workload-def"  , cl::desc("Pass a workload definition. This is a file containing a JSON " "dictionary. The keys are root functions, the values are lists of " "functions to import in the module defining the root. It is " "assumed -funique-internal-linkage-names was used, to ensure " "local linkage functions have unique names. For example: \n" "{\n" " \"rootFunction_1\": [\"function_to_import_1\", " "\"function_to_import_2\"], \n" " \"rootFunction_2\": [\"function_to_import_3\", " "\"function_to_import_4\"] \n" "}")  , cl::Hidden    )

static

Pass a workload description file - an example of workload would be the functions executed to satisfy a RPC request.

A workload is defined by a root function and the list of functions that are (frequently) needed to satisfy it. The module that defines the root will have all those functions imported. The file contains a JSON dictionary. The keys are root functions, the values are lists of functions to import in the module defining the root. It is assumed -funique-internal-linkage-names was used, thus ensuring function names are unique even for local linkage ones.

Referenced by ModuleImportsManager::create(), and WorkloadImportsManager::WorkloadImportsManager().