Skip to content

Commit 6388b96

Browse files
rintarorintaro
committed
[Macros] Move 'loadExecutablePlugin' logic to 'CompilerPluginLoadRequest'
Separate "load plugin" and "resolve macro" phases. So that the loaded executable plugin is now cached in ASTContext and reused. This saves a 'loadPluginLibrary' IPC messaging when the library provides multiple macros.
1 parent 92e5ad6 commit 6388b96

File tree

3 files changed

+116
-68
lines changed

3 files changed

+116
-68
lines changed

‎include/swift/AST/TypeCheckRequests.h

Lines changed: 39 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,7 @@ struct ExternalMacroDefinition;
4949
class ClosureExpr;
5050
class GenericParamList;
5151
class LabeledStmt;
52+
class LoadedExecutablePlugin;
5253
class MacroDefinition;
5354
class PrecedenceGroupDecl;
5455
class PropertyWrapperInitializerInfo;
@@ -4000,19 +4001,51 @@ class ExpandSynthesizedMemberMacroRequest
40004001
/// Load a plugin module with the given name.
40014002
///
40024003
///
4004+
class LoadedCompilerPlugin {
4005+
enum class PluginKind : uint8_t {
4006+
None,
4007+
InProcess,
4008+
Executable,
4009+
};
4010+
PluginKind kind;
4011+
void *ptr;
4012+
4013+
LoadedCompilerPlugin(PluginKind kind, void *ptr) : kind(kind), ptr(ptr) {
4014+
assert(ptr != nullptr || kind == PluginKind::None);
4015+
}
4016+
4017+
public:
4018+
LoadedCompilerPlugin(std::nullptr_t) : kind(PluginKind::None), ptr(nullptr) {}
4019+
4020+
static LoadedCompilerPlugin inProcess(void *ptr) {
4021+
return {PluginKind::InProcess, ptr};
4022+
}
4023+
static LoadedCompilerPlugin executable(LoadedExecutablePlugin *ptr) {
4024+
return {PluginKind::Executable, ptr};
4025+
}
4026+
4027+
void *getAsInProcessPlugin() const {
4028+
return kind == PluginKind::InProcess ? static_cast<void *>(ptr) : nullptr;
4029+
}
4030+
LoadedExecutablePlugin *getAsExecutablePlugin() const {
4031+
return kind == PluginKind::Executable
4032+
? static_cast<LoadedExecutablePlugin *>(ptr)
4033+
: nullptr;
4034+
}
4035+
};
4036+
40034037
class CompilerPluginLoadRequest
4004-
: public SimpleRequest<CompilerPluginLoadRequest,
4005-
void *(ASTContext *, Identifier),
4006-
RequestFlags::Cached> {
4038+
: public SimpleRequest<CompilerPluginLoadRequest,
4039+
LoadedCompilerPlugin(ASTContext *, Identifier),
4040+
RequestFlags::Cached> {
40074041
public:
40084042
using SimpleRequest::SimpleRequest;
40094043

40104044
private:
40114045
friend SimpleRequest;
40124046

4013-
void *evaluate(
4014-
Evaluator &evaluator, ASTContext *ctx, Identifier moduleName
4015-
) const;
4047+
LoadedCompilerPlugin evaluate(Evaluator &evaluator, ASTContext *ctx,
4048+
Identifier moduleName) const;
40164049

40174050
public:
40184051
// Source location

‎include/swift/AST/TypeCheckerTypeIDZone.def

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -431,7 +431,7 @@ SWIFT_REQUEST(TypeChecker, MacroDefinitionRequest,
431431
MacroDefinition(MacroDecl *),
432432
Cached, NoLocationInfo)
433433
SWIFT_REQUEST(TypeChecker, CompilerPluginLoadRequest,
434-
void *(ASTContext *, Identifier),
434+
LoadedCompilerPlugin(ASTContext *, Identifier),
435435
Cached, NoLocationInfo)
436436
SWIFT_REQUEST(TypeChecker, ExternalMacroDefinitionRequest,
437437
Optional<ExternalMacroDefinition>(ASTContext *, Identifier, Identifier),

‎lib/Sema/TypeCheckMacros.cpp

Lines changed: 76 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -286,10 +286,9 @@ MacroDefinition MacroDefinitionRequest::evaluate(
286286
}
287287

288288
/// Load a plugin library based on a module name.
289-
static void *loadPluginByName(StringRef searchPath,
290-
StringRef moduleName,
291-
llvm::vfs::FileSystem &fs,
292-
PluginRegistry *registry) {
289+
static void *loadLibraryPluginByName(StringRef searchPath, StringRef moduleName,
290+
llvm::vfs::FileSystem &fs,
291+
PluginRegistry *registry) {
293292
SmallString<128> fullPath(searchPath);
294293
llvm::sys::path::append(fullPath, "lib" + moduleName + LTDL_SHLIB_EXT);
295294
if (fs.getRealPath(fullPath, fullPath))
@@ -298,53 +297,12 @@ static void *loadPluginByName(StringRef searchPath,
298297
return loadResult ? *loadResult : nullptr;
299298
}
300299

301-
void *CompilerPluginLoadRequest::evaluate(
302-
Evaluator &evaluator, ASTContext *ctx, Identifier moduleName
303-
) const {
304-
auto fs = ctx->SourceMgr.getFileSystem();
305-
auto &searchPathOpts = ctx->SearchPathOpts;
306-
auto *registry = ctx->getPluginRegistry();
307-
for (const auto &path : searchPathOpts.PluginSearchPaths) {
308-
if (auto found = loadPluginByName(path, moduleName.str(), *fs, registry))
309-
return found;
310-
}
311-
312-
return nullptr;
313-
}
314-
315-
static Optional<ExternalMacroDefinition>
316-
resolveInProcessMacro(
317-
ASTContext &ctx, Identifier moduleName, Identifier typeName,
318-
void *libraryHint = nullptr
319-
) {
320-
#if SWIFT_SWIFT_PARSER
321-
/// Look for the type metadata given the external module and type names.
322-
auto macroMetatype = lookupMacroTypeMetadataByExternalName(
323-
ctx, moduleName.str(), typeName.str(), libraryHint);
324-
if (macroMetatype) {
325-
// Check whether the macro metatype is in-process.
326-
if (auto inProcess = swift_ASTGen_resolveMacroType(macroMetatype)) {
327-
// Make sure we clean up after the macro.
328-
ctx.addCleanup([inProcess]() {
329-
swift_ASTGen_destroyMacro(inProcess);
330-
});
331-
332-
return ExternalMacroDefinition{
333-
ExternalMacroDefinition::PluginKind::InProcess, inProcess};
334-
}
335-
}
336-
#endif
337-
return None;
338-
}
339-
340-
static Optional<ExternalMacroDefinition>
341-
resolveExecutableMacro(ASTContext &ctx, Identifier moduleName,
342-
Identifier typeName) {
343-
#if SWIFT_SWIFT_PARSER
344-
std::string executablePluginPath;
300+
static LoadedExecutablePlugin *
301+
loadExecutablePluginByName(ASTContext &ctx, Identifier moduleName) {
302+
// Find an executable plugin.
345303
std::string libraryPath;
304+
std::string executablePluginPath;
346305

347-
// Find macros in executable plugins.
348306
if (auto found = ctx.lookupExternalLibraryPluginByModuleName(moduleName)) {
349307
// Found in '-external-plugin-path'.
350308
std::tie(libraryPath, executablePluginPath) = found.value();
@@ -353,13 +311,13 @@ resolveExecutableMacro(ASTContext &ctx, Identifier moduleName,
353311
executablePluginPath = found->str();
354312
}
355313
if (executablePluginPath.empty())
356-
return None;
314+
return nullptr;
357315

358316
// Launch the plugin.
359317
LoadedExecutablePlugin *executablePlugin =
360318
ctx.loadExecutablePlugin(executablePluginPath);
361319
if (!executablePlugin)
362-
return None;
320+
return nullptr;
363321

364322
// FIXME: Ideally this should be done right after invoking the plugin.
365323
// But plugin loading is in libAST and it can't link ASTGen symbols.
@@ -370,21 +328,76 @@ resolveExecutableMacro(ASTContext &ctx, Identifier moduleName,
370328
});
371329
}
372330

373-
// If this is a plugin server. Load the library in that process before
374-
// resolving the macro.
331+
// If this is a plugin server, load the library.
375332
if (!libraryPath.empty()) {
376333
llvm::SmallString<128> resolvedLibraryPath;
377334
auto fs = ctx.SourceMgr.getFileSystem();
378335
if (fs->getRealPath(libraryPath, resolvedLibraryPath)) {
379-
return None;
336+
return nullptr;
380337
}
381338
bool loaded = swift_ASTGen_pluginServerLoadLibraryPlugin(
382339
executablePlugin, resolvedLibraryPath.c_str(), moduleName.str().data(),
383340
&ctx.Diags);
384341
if (!loaded)
385-
return None;
342+
return nullptr;
343+
}
344+
345+
return executablePlugin;
346+
}
347+
348+
LoadedCompilerPlugin
349+
CompilerPluginLoadRequest::evaluate(Evaluator &evaluator, ASTContext *ctx,
350+
Identifier moduleName) const {
351+
auto fs = ctx->SourceMgr.getFileSystem();
352+
auto &searchPathOpts = ctx->SearchPathOpts;
353+
auto *registry = ctx->getPluginRegistry();
354+
355+
// First, check '-plugin-path' paths.
356+
for (const auto &path : searchPathOpts.PluginSearchPaths) {
357+
if (auto found =
358+
loadLibraryPluginByName(path, moduleName.str(), *fs, registry))
359+
return LoadedCompilerPlugin::inProcess(found);
386360
}
387361

362+
// Fall back to executable plugins.
363+
// i.e. '-external-plugin-path', and '-load-plugin-executable'.
364+
if (auto *found = loadExecutablePluginByName(*ctx, moduleName)) {
365+
return LoadedCompilerPlugin::executable(found);
366+
}
367+
368+
return nullptr;
369+
}
370+
371+
static Optional<ExternalMacroDefinition>
372+
resolveInProcessMacro(
373+
ASTContext &ctx, Identifier moduleName, Identifier typeName,
374+
void *libraryHint = nullptr
375+
) {
376+
#if SWIFT_SWIFT_PARSER
377+
/// Look for the type metadata given the external module and type names.
378+
auto macroMetatype = lookupMacroTypeMetadataByExternalName(
379+
ctx, moduleName.str(), typeName.str(), libraryHint);
380+
if (macroMetatype) {
381+
// Check whether the macro metatype is in-process.
382+
if (auto inProcess = swift_ASTGen_resolveMacroType(macroMetatype)) {
383+
// Make sure we clean up after the macro.
384+
ctx.addCleanup([inProcess]() {
385+
swift_ASTGen_destroyMacro(inProcess);
386+
});
387+
388+
return ExternalMacroDefinition{
389+
ExternalMacroDefinition::PluginKind::InProcess, inProcess};
390+
}
391+
}
392+
#endif
393+
return None;
394+
}
395+
396+
static Optional<ExternalMacroDefinition>
397+
resolveExecutableMacro(ASTContext &ctx,
398+
LoadedExecutablePlugin *executablePlugin,
399+
Identifier moduleName, Identifier typeName) {
400+
#if SWIFT_SWIFT_PARSER
388401
if (auto *execMacro = swift_ASTGen_resolveExecutableMacro(
389402
moduleName.str().data(), moduleName.str().size(),
390403
typeName.str().data(), typeName.str().size(), executablePlugin)) {
@@ -395,7 +408,6 @@ resolveExecutableMacro(ASTContext &ctx, Identifier moduleName,
395408
ExternalMacroDefinition::PluginKind::Executable, execMacro};
396409
}
397410
#endif
398-
399411
return None;
400412
}
401413

@@ -406,8 +418,9 @@ ExternalMacroDefinitionRequest::evaluate(Evaluator &evaluator, ASTContext *ctx,
406418
// Try to load a plugin module from the plugin search paths. If it
407419
// succeeds, resolve in-process from that plugin
408420
CompilerPluginLoadRequest loadRequest{ctx, moduleName};
409-
if (auto loadedLibrary = evaluateOrDefault(
410-
evaluator, loadRequest, nullptr)) {
421+
LoadedCompilerPlugin loaded =
422+
evaluateOrDefault(evaluator, loadRequest, nullptr);
423+
if (auto loadedLibrary = loaded.getAsInProcessPlugin()) {
411424
if (auto inProcess = resolveInProcessMacro(
412425
*ctx, moduleName, typeName, loadedLibrary))
413426
return *inProcess;
@@ -418,9 +431,11 @@ ExternalMacroDefinitionRequest::evaluate(Evaluator &evaluator, ASTContext *ctx,
418431
return *inProcess;
419432

420433
// Try executable plugins.
421-
if (auto executableMacro =
422-
resolveExecutableMacro(*ctx, moduleName, typeName)) {
423-
return executableMacro;
434+
if (auto *executablePlugin = loaded.getAsExecutablePlugin()) {
435+
if (auto executableMacro = resolveExecutableMacro(*ctx, executablePlugin,
436+
moduleName, typeName)) {
437+
return executableMacro;
438+
}
424439
}
425440

426441
return None;

0 commit comments

Comments
 (0)