ClangImporter.cpp

//===--- ClangImporter.cpp - Import Clang Modules -------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file implements support for loading Clang modules into Swift.
//
//===----------------------------------------------------------------------===//
#include"swift/ClangImporter/ClangImporter.h"
#include"CFTypeInfo.h"
#include"ClangDerivedConformances.h"
#include"ClangDiagnosticConsumer.h"
#include"ClangIncludePaths.h"
#include"ImporterImpl.h"
#include"SwiftDeclSynthesizer.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/Builtins.h"
#include"swift/AST/ClangModuleLoader.h"
#include"swift/AST/ConcreteDeclRef.h"
#include"swift/AST/DiagnosticEngine.h"
#include"swift/AST/DiagnosticsClangImporter.h"
#include"swift/AST/DiagnosticsSema.h"
#include"swift/AST/Evaluator.h"
#include"swift/AST/IRGenOptions.h"
#include"swift/AST/ImportCache.h"
#include"swift/AST/LinkLibrary.h"
#include"swift/AST/Module.h"
#include"swift/AST/ModuleNameLookup.h"
#include"swift/AST/NameLookup.h"
#include"swift/AST/NameLookupRequests.h"
#include"swift/AST/PrettyStackTrace.h"
#include"swift/AST/SourceFile.h"
#include"swift/AST/Type.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/AST/Types.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/Defer.h"
#include"swift/Basic/LLVM.h"
#include"swift/Basic/Platform.h"
#include"swift/Basic/Range.h"
#include"swift/Basic/SourceLoc.h"
#include"swift/Basic/StringExtras.h"
#include"swift/Basic/Version.h"
#include"swift/ClangImporter/ClangImporterRequests.h"
#include"swift/ClangImporter/ClangModule.h"
#include"swift/Frontend/CompileJobCacheKey.h"
#include"swift/Parse/ParseVersion.h"
#include"swift/Strings.h"
#include"swift/Subsystems.h"
#include"clang/AST/ASTContext.h"
#include"clang/AST/Decl.h"
#include"clang/AST/DeclBase.h"
#include"clang/AST/DeclCXX.h"
#include"clang/AST/DeclTemplate.h"
#include"clang/AST/Mangle.h"
#include"clang/AST/TemplateBase.h"
#include"clang/AST/Type.h"
#include"clang/Basic/DiagnosticOptions.h"
#include"clang/Basic/FileEntry.h"
#include"clang/Basic/IdentifierTable.h"
#include"clang/Basic/LangStandard.h"
#include"clang/Basic/Module.h"
#include"clang/Basic/Specifiers.h"
#include"clang/Basic/TargetInfo.h"
#include"clang/CAS/CASOptions.h"
#include"clang/CAS/IncludeTree.h"
#include"clang/CodeGen/ObjectFilePCHContainerWriter.h"
#include"clang/Frontend/CompilerInvocation.h"
#include"clang/Frontend/FrontendActions.h"
#include"clang/Frontend/FrontendOptions.h"
#include"clang/Frontend/IncludeTreePPActions.h"
#include"clang/Frontend/TextDiagnosticPrinter.h"
#include"clang/Frontend/Utils.h"
#include"clang/Index/IndexingAction.h"
#include"clang/Lex/Preprocessor.h"
#include"clang/Lex/PreprocessorOptions.h"
#include"clang/Parse/Parser.h"
#include"clang/Rewrite/Frontend/Rewriters.h"
#include"clang/Sema/DelayedDiagnostic.h"
#include"clang/Sema/Lookup.h"
#include"clang/Sema/Sema.h"
#include"clang/Serialization/ASTReader.h"
#include"clang/Serialization/ASTWriter.h"
#include"clang/Serialization/ObjectFilePCHContainerReader.h"
#include"clang/Tooling/DependencyScanning/ScanAndUpdateArgs.h"
#include"llvm/ADT/IntrusiveRefCntPtr.h"
#include"llvm/ADT/STLExtras.h"
#include"llvm/ADT/SmallVector.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/ADT/StringRef.h"
#include"llvm/ADT/TypeSwitch.h"
#include"llvm/CAS/CASReference.h"
#include"llvm/CAS/ObjectStore.h"
#include"llvm/Support/Casting.h"
#include"llvm/Support/CrashRecoveryContext.h"
#include"llvm/Support/Error.h"
#include"llvm/Support/ErrorHandling.h"
#include"llvm/Support/FileCollector.h"
#include"llvm/Support/FileSystem.h"
#include"llvm/Support/Memory.h"
#include"llvm/Support/Path.h"
#include"llvm/Support/PrefixMapper.h"
#include"llvm/Support/VirtualFileSystem.h"
#include"llvm/TextAPI/InterfaceFile.h"
#include"llvm/TextAPI/TextAPIReader.h"
#include<algorithm>
#include<memory>
#include<optional>
#include<string>
#include<utility>

usingnamespaceswift;
usingnamespaceimporter;

// Commonly-used Clang classes.
using clang::CompilerInstance;
using clang::CompilerInvocation;

#pragma mark Internal data structures

namespace {
classHeaderImportCallbacks : publicclang::PPCallbacks {
 ClangImporter::Implementation &Impl;
public:
HeaderImportCallbacks(ClangImporter::Implementation &impl)
 : Impl(impl) {}

voidhandleImport(const clang::Module *imported) {
if (!imported)
return;
 Impl.ImportedHeaderExports.push_back(
const_cast<clang::Module *>(imported));
 }

voidInclusionDirective(
 clang::SourceLocation HashLoc, const clang::Token &IncludeTok,
 StringRef FileName, bool IsAngled, clang::CharSourceRange FilenameRange,
 clang::OptionalFileEntryRef File, StringRef SearchPath,
 StringRef RelativePath, const clang::Module *SuggestedModule,
bool ModuleImported,
 clang::SrcMgr::CharacteristicKind FileType) override {
handleImport(ModuleImported ? SuggestedModule : nullptr);
 }

voidmoduleImport(clang::SourceLocation ImportLoc,
 clang::ModuleIdPath Path,
const clang::Module *Imported) override {
handleImport(Imported);
 }
 };

classPCHDeserializationCallbacks : publicclang::ASTDeserializationListener {
 ClangImporter::Implementation &Impl;
public:
explicitPCHDeserializationCallbacks(ClangImporter::Implementation &impl)
 : Impl(impl) {}
voidModuleImportRead(clang::serialization::SubmoduleID ID,
 clang::SourceLocation ImportLoc) override {
if (Impl.IsReadingBridgingPCH) {
 Impl.PCHImportedSubmodules.push_back(ID);
 }
 }
 };

classHeaderParsingASTConsumer : publicclang::ASTConsumer {
 SmallVector<clang::DeclGroupRef, 4> DeclGroups;
 PCHDeserializationCallbacks PCHCallbacks;
public:
explicitHeaderParsingASTConsumer(ClangImporter::Implementation &impl)
 : PCHCallbacks(impl) {}
void
HandleTopLevelDeclInObjCContainer(clang::DeclGroupRef decls) override {
 DeclGroups.push_back(decls);
 }

 ArrayRef<clang::DeclGroupRef> getAdditionalParsedDecls() {
return DeclGroups;
 }

 clang::ASTDeserializationListener *GetASTDeserializationListener() override {
return &PCHCallbacks;
 }

voidreset() {
 DeclGroups.clear();
 }
 };

classParsingAction : publicclang::ASTFrontendAction {
 ClangImporter &Importer;
 ClangImporter::Implementation &Impl;
const ClangImporterOptions &ImporterOpts;
 std::string SwiftPCHHash;
public:
explicitParsingAction(ClangImporter &importer,
 ClangImporter::Implementation &impl,
const ClangImporterOptions &importerOpts,
 std::string swiftPCHHash)
 : Importer(importer), Impl(impl), ImporterOpts(importerOpts),
 SwiftPCHHash(swiftPCHHash) {}
 std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &CI, StringRef InFile) override {
return std::make_unique<HeaderParsingASTConsumer>(Impl);
 }
boolBeginSourceFileAction(clang::CompilerInstance &CI) override {
auto PCH =
 Importer.getOrCreatePCH(ImporterOpts, SwiftPCHHash, /*Cached=*/true);
if (PCH.has_value()) {
 Impl.getClangInstance()->getPreprocessorOpts().ImplicitPCHInclude =
 PCH.value();
 Impl.IsReadingBridgingPCH = true;
 Impl.setSinglePCHImport(PCH.value());
 }

returntrue;
 }
 };

classStdStringMemBuffer : publicllvm::MemoryBuffer {
const std::string storage;
const std::string name;
public:
StdStringMemBuffer(std::string &&source, StringRef name)
 : storage(std::move(source)), name(name.str()) {
init(storage.data(), storage.data() + storage.size(),
/*null-terminated=*/true);
 }

 StringRef getBufferIdentifier() constoverride {
return name;
 }

 BufferKind getBufferKind() constoverride {
return MemoryBuffer_Malloc;
 }
 };

classZeroFilledMemoryBuffer : publicllvm::MemoryBuffer {
const std::string name;
public:
explicitZeroFilledMemoryBuffer(size_t size, StringRef name)
 : name(name.str()) {
assert(size > 0);
 std::error_code error;
 llvm::sys::MemoryBlock memory =
llvm::sys::Memory::allocateMappedMemory(size, nullptr,
 llvm::sys::Memory::MF_READ,
 error);
assert(!error && "failed to allocated read-only zero-filled memory");
init(static_cast<char *>(memory.base()),
static_cast<char *>(memory.base()) + memory.allocatedSize() - 1,
/*null-terminated*/true);
 }

~ZeroFilledMemoryBuffer() override {
 llvm::sys::MemoryBlock memory{const_cast<char *>(getBufferStart()),
getBufferSize()};
 std::error_code error = llvm::sys::Memory::releaseMappedMemory(memory);
assert(!error && "failed to deallocate read-only zero-filled memory");
 (void)error;
 }

ZeroFilledMemoryBuffer(const ZeroFilledMemoryBuffer &) = delete;
ZeroFilledMemoryBuffer(ZeroFilledMemoryBuffer &&) = delete;
voidoperator=(const ZeroFilledMemoryBuffer &) = delete;
voidoperator=(ZeroFilledMemoryBuffer &&) = delete;

 StringRef getBufferIdentifier() constoverride {
return name;
 }
 BufferKind getBufferKind() constoverride {
return MemoryBuffer_MMap;
 }
 };
} // end anonymous namespace

namespace {
classBridgingPPTracker : publicclang::PPCallbacks {
 ClangImporter::Implementation &Impl;

public:
BridgingPPTracker(ClangImporter::Implementation &Impl)
 : Impl(Impl) {}

private:
staticunsignedgetNumModuleIdentifiers(const clang::Module *Mod) {
unsigned Result = 1;
while (Mod->Parent) {
 Mod = Mod->Parent;
 ++Result;
 }
return Result;
 }

voidInclusionDirective(clang::SourceLocation HashLoc,
const clang::Token &IncludeTok, StringRef FileName,
bool IsAngled, clang::CharSourceRange FilenameRange,
 clang::OptionalFileEntryRef File,
 StringRef SearchPath, StringRef RelativePath,
const clang::Module *SuggestedModule,
bool ModuleImported,
 clang::SrcMgr::CharacteristicKind FileType) override {
if (!ModuleImported) {
if (File)
 Impl.BridgeHeaderFiles.insert(*File);
return;
 }
// Synthesize identifier locations.
 SmallVector<clang::SourceLocation, 4> IdLocs;
for (unsigned I = 0, E = getNumModuleIdentifiers(SuggestedModule); I != E; ++I)
 IdLocs.push_back(HashLoc);
handleImport(HashLoc, IdLocs, SuggestedModule);
 }

voidmoduleImport(clang::SourceLocation ImportLoc,
 clang::ModuleIdPath Path,
const clang::Module *Imported) override {
if (!Imported)
return;
 SmallVector<clang::SourceLocation, 4> IdLocs;
for (auto &P : Path)
 IdLocs.push_back(P.second);
handleImport(ImportLoc, IdLocs, Imported);
 }

voidhandleImport(clang::SourceLocation ImportLoc,
 ArrayRef<clang::SourceLocation> IdLocs,
const clang::Module *Imported) {
 clang::ASTContext &ClangCtx = Impl.getClangASTContext();
 clang::ImportDecl *ClangImport = clang::ImportDecl::Create(ClangCtx,
 ClangCtx.getTranslationUnitDecl(),
 ImportLoc,
const_cast<clang::Module*>(Imported),
 IdLocs);
 Impl.BridgeHeaderTopLevelImports.push_back(ClangImport);
 }

voidMacroDefined(const clang::Token &MacroNameTok,
const clang::MacroDirective *MD) override {
 Impl.BridgeHeaderMacros.push_back(MacroNameTok.getIdentifierInfo());
 }
};

classClangImporterDependencyCollector : publicclang::DependencyCollector
{
 llvm::StringSet<> ExcludedPaths;
/// The FileCollector is used by LLDB to generate reproducers. It's not used
/// by Swift to track dependencies.
 std::shared_ptr<llvm::FileCollectorBase> FileCollector;
const IntermoduleDepTrackingMode Mode;

public:
ClangImporterDependencyCollector(
 IntermoduleDepTrackingMode Mode,
 std::shared_ptr<llvm::FileCollectorBase> FileCollector)
 : FileCollector(FileCollector), Mode(Mode) {}

voidexcludePath(StringRef filename) {
 ExcludedPaths.insert(filename);
 }

boolisClangImporterSpecialName(StringRef Filename) {
using ImporterImpl = ClangImporter::Implementation;
return (Filename == ImporterImpl::moduleImportBufferName
 || Filename == ImporterImpl::bridgingHeaderBufferName);
 }

boolneedSystemDependencies() override {
return Mode == IntermoduleDepTrackingMode::IncludeSystem;
 }

boolsawDependency(StringRef Filename, bool FromClangModule,
bool IsSystem, bool IsClangModuleFile,
bool IsMissing) override {
if (!clang::DependencyCollector::sawDependency(Filename, FromClangModule,
 IsSystem, IsClangModuleFile,
 IsMissing))
returnfalse;
// Currently preserving older ClangImporter behavior of ignoring .pcm
// file dependencies, but possibly revisit?
if (IsClangModuleFile
 || isClangImporterSpecialName(Filename)
 || ExcludedPaths.count(Filename))
returnfalse;
returntrue;
 }

voidmaybeAddDependency(StringRef Filename, bool FromModule, bool IsSystem,
bool IsModuleFile, bool IsMissing) override {
if (FileCollector)
 FileCollector->addFile(Filename);
clang::DependencyCollector::maybeAddDependency(
 Filename, FromModule, IsSystem, IsModuleFile, IsMissing);
 }
};
} // end anonymous namespace

std::shared_ptr<clang::DependencyCollector>
ClangImporter::createDependencyCollector(
 IntermoduleDepTrackingMode Mode,
 std::shared_ptr<llvm::FileCollectorBase> FileCollector) {
return std::make_shared<ClangImporterDependencyCollector>(Mode,
 FileCollector);
}

boolClangImporter::isKnownCFTypeName(llvm::StringRef name) {
returnCFPointeeInfo::isKnownCFTypeName(name);
}

voidClangImporter::Implementation::addBridgeHeaderTopLevelDecls(
 clang::Decl *D) {
if (shouldIgnoreBridgeHeaderTopLevelDecl(D))
return;

 BridgeHeaderTopLevelDecls.push_back(D);
}

boolimporter::isForwardDeclOfType(const clang::Decl *D) {
if (auto *ID = dyn_cast<clang::ObjCInterfaceDecl>(D)) {
if (!ID->isThisDeclarationADefinition())
returntrue;
 } elseif (auto PD = dyn_cast<clang::ObjCProtocolDecl>(D)) {
if (!PD->isThisDeclarationADefinition())
returntrue;
 } elseif (auto TD = dyn_cast<clang::TagDecl>(D)) {
if (!TD->isThisDeclarationADefinition())
returntrue;
 }
returnfalse;
}

boolClangImporter::Implementation::shouldIgnoreBridgeHeaderTopLevelDecl(
 clang::Decl *D) {
returnimporter::isForwardDeclOfType(D);
}

ClangImporter::ClangImporter(ASTContext &ctx,
 DependencyTracker *tracker,
 DWARFImporterDelegate *dwarfImporterDelegate)
 : ClangModuleLoader(tracker),
 Impl(*new Implementation(ctx, tracker, dwarfImporterDelegate)) {
}

ClangImporter::~ClangImporter() {
delete &Impl;
}

#pragma mark Module loading

staticboolclangSupportsPragmaAttributeWithSwiftAttr() {
 clang::AttributeCommonInfo swiftAttrInfo(clang::SourceRange(),
 clang::AttributeCommonInfo::AT_SwiftAttr,
clang::AttributeCommonInfo::Form::GNU());
auto swiftAttrParsedInfo = clang::ParsedAttrInfo::get(swiftAttrInfo);
return swiftAttrParsedInfo.IsSupportedByPragmaAttribute;
}

staticinlineboolisPCHFilenameExtension(StringRef path) {
returnllvm::sys::path::extension(path)
 .ends_with(file_types::getExtension(file_types::TY_PCH));
}

voidimporter::getNormalInvocationArguments(
 std::vector<std::string> &invocationArgStrs, ASTContext &ctx,
bool ignoreClangTarget) {
constauto &LangOpts = ctx.LangOpts;
 llvm::Triple triple = LangOpts.Target;
// Use clang specific target triple if given.
if (LangOpts.ClangTarget.has_value() && !ignoreClangTarget) {
 triple = LangOpts.ClangTarget.value();
 }
 SearchPathOptions &searchPathOpts = ctx.SearchPathOpts;
 ClangImporterOptions &importerOpts = ctx.ClangImporterOpts;
auto languageVersion = ctx.LangOpts.EffectiveLanguageVersion;

auto bridgingPCH = importerOpts.getPCHInputPath();
if (!bridgingPCH.empty())
 invocationArgStrs.insert(invocationArgStrs.end(),
 {"-include-pch", bridgingPCH});

// If there are no shims in the resource dir, add a search path in the SDK.
 SmallString<128> shimsPath(searchPathOpts.RuntimeResourcePath);
llvm::sys::path::append(shimsPath, "shims");
if (!llvm::sys::fs::exists(shimsPath)) {
 shimsPath = searchPathOpts.getSDKPath();
llvm::sys::path::append(shimsPath, "usr", "lib", "swift", "shims");
 invocationArgStrs.insert(invocationArgStrs.end(),
 {"-isystem", std::string(shimsPath.str())});
 }

// Construct the invocation arguments for the current target.
// Add target-independent options first.
 invocationArgStrs.insert(invocationArgStrs.end(), {
// Don't emit LLVM IR.
"-fsyntax-only",

// Enable block support.
"-fblocks",

 languageVersion.preprocessorDefinition("__swift__", {10000, 100, 1}),

"-fretain-comments-from-system-headers",

"-isystem", searchPathOpts.RuntimeResourcePath,
 });

// Enable Position Independence. `-fPIC` is not supported on Windows, which
// is implicitly position independent.
if (!triple.isOSWindows())
 invocationArgStrs.insert(invocationArgStrs.end(), {"-fPIC"});

// Enable modules.
 invocationArgStrs.insert(invocationArgStrs.end(), {
"-fmodules",
"-Xclang", "-fmodule-feature", "-Xclang", "swift"
 });

bool EnableCXXInterop = LangOpts.EnableCXXInterop;

if (LangOpts.EnableObjCInterop) {
 invocationArgStrs.insert(invocationArgStrs.end(), {"-fobjc-arc"});
// TODO: Investigate whether 7.0 is a suitable default version.
if (!triple.isOSDarwin())
 invocationArgStrs.insert(invocationArgStrs.end(),
 {"-fobjc-runtime=ios-7.0"});

 invocationArgStrs.insert(invocationArgStrs.end(), {
"-x", EnableCXXInterop ? "objective-c++" : "objective-c",
 });
 } else {
 invocationArgStrs.insert(invocationArgStrs.end(), {
"-x", EnableCXXInterop ? "c++" : "c",
 });
 }

 {
const clang::LangStandard &stdcxx =
#if defined(CLANG_DEFAULT_STD_CXX)
 *clang::LangStandard::getLangStandardForName(CLANG_DEFAULT_STD_CXX);
#else
clang::LangStandard::getLangStandardForKind(
 clang::LangStandard::lang_gnucxx17);
#endif

const clang::LangStandard &stdc =
#if defined(CLANG_DEFAULT_STD_C)
 *clang::LangStandard::getLangStandardForName(CLANG_DEFAULT_STD_C);
#else
clang::LangStandard::getLangStandardForKind(
 clang::LangStandard::lang_gnu11);
#endif

 invocationArgStrs.insert(invocationArgStrs.end(), {
 (Twine("-std=") + StringRef(EnableCXXInterop ? stdcxx.getName()
 : stdc.getName())).str()
 });
 }

if (LangOpts.EnableCXXInterop) {
if (auto path = getCxxShimModuleMapPath(searchPathOpts, LangOpts, triple)) {
 invocationArgStrs.push_back((Twine("-fmodule-map-file=") + *path).str());
 }
 }

if (LangOpts.hasFeature(Feature::SafeInteropWrappers))
 invocationArgStrs.push_back("-fexperimental-bounds-safety-attributes");

// Set C language options.
if (triple.isOSDarwin()) {
 invocationArgStrs.insert(invocationArgStrs.end(), {
// Avoid including the iso646.h header because some headers from OS X
// frameworks are broken by it.
"-D_ISO646_H_", "-D__ISO646_H",

// Request new APIs from AppKit.
"-DSWIFT_SDK_OVERLAY_APPKIT_EPOCH=2",

// Request new APIs from Foundation.
"-DSWIFT_SDK_OVERLAY_FOUNDATION_EPOCH=8",

// Request new APIs from SceneKit.
"-DSWIFT_SDK_OVERLAY2_SCENEKIT_EPOCH=3",

// Request new APIs from GameplayKit.
"-DSWIFT_SDK_OVERLAY_GAMEPLAYKIT_EPOCH=1",

// Request new APIs from SpriteKit.
"-DSWIFT_SDK_OVERLAY_SPRITEKIT_EPOCH=1",

// Request new APIs from CoreImage.
"-DSWIFT_SDK_OVERLAY_COREIMAGE_EPOCH=2",

// Request new APIs from libdispatch.
"-DSWIFT_SDK_OVERLAY_DISPATCH_EPOCH=2",

// Request new APIs from libpthread
"-DSWIFT_SDK_OVERLAY_PTHREAD_EPOCH=1",

// Request new APIs from CoreGraphics.
"-DSWIFT_SDK_OVERLAY_COREGRAPHICS_EPOCH=0",

// Request new APIs from UIKit.
"-DSWIFT_SDK_OVERLAY_UIKIT_EPOCH=2",

// Backwards compatibility for headers that were checking this instead of
// '__swift__'.
"-DSWIFT_CLASS_EXTRA=",
 });

// Indicate that using '__attribute__((swift_attr))' with '@Sendable' and
// '@_nonSendable' on Clang declarations is fully supported, including the
// 'attribute push' pragma.
if (clangSupportsPragmaAttributeWithSwiftAttr())
 invocationArgStrs.push_back("-D__SWIFT_ATTR_SUPPORTS_SENDABLE_DECLS=1");

if (triple.isXROS()) {
// FIXME: This is a gnarly hack until some macros get adjusted in the SDK.
 invocationArgStrs.insert(invocationArgStrs.end(), {
"-DOS_OBJECT_HAVE_OBJC_SUPPORT=1",
 });
 }

// Get the version of this compiler and pass it to C/Objective-C
// declarations.
auto V = version::getCurrentCompilerVersion();
if (!V.empty()) {
// Note: Prior to Swift 5.7, the "Y" version component was omitted and the
// "X" component resided in its digits.
 invocationArgStrs.insert(invocationArgStrs.end(), {
 V.preprocessorDefinition("__SWIFT_COMPILER_VERSION",
 {1000000000000, // X
1000000000, // Y
1000000, // Z
1000, // a
1}), // b
 });
 }
 } else {
// Ideally we should turn this on for all Glibc targets that are actually
// using Glibc or a libc that respects that flag. This will cause some
// source breakage however (specifically with strerror_r()) on Linux
// without a workaround.
if (triple.isOSFuchsia() || triple.isAndroid() || triple.isMusl()) {
// Many of the modern libc features are hidden behind feature macros like
// _GNU_SOURCE or _XOPEN_SOURCE.
 invocationArgStrs.insert(invocationArgStrs.end(), {
"-D_GNU_SOURCE",
 });
 }

if (triple.isOSWindows()) {
switch (triple.getArch()) {
default: llvm_unreachable("unsupported Windows architecture");
case llvm::Triple::arm:
case llvm::Triple::thumb:
 invocationArgStrs.insert(invocationArgStrs.end(), {"-D_ARM_"});
break;
case llvm::Triple::aarch64:
case llvm::Triple::aarch64_32:
 invocationArgStrs.insert(invocationArgStrs.end(), {"-D_ARM64_"});
break;
case llvm::Triple::x86:
 invocationArgStrs.insert(invocationArgStrs.end(), {"-D_X86_"});
break;
case llvm::Triple::x86_64:
 invocationArgStrs.insert(invocationArgStrs.end(), {"-D_AMD64_"});
break;
 }
 }
 }

// If we support SendingArgsAndResults, set the -D flag to signal that it
// is supported.
if (LangOpts.hasFeature(Feature::SendingArgsAndResults))
 invocationArgStrs.push_back("-D__SWIFT_ATTR_SUPPORTS_SENDING=1");

// Indicate that the compiler will respect macros applied to imported
// declarations via '__attribute__((swift_attr("@...")))'.
if (LangOpts.hasFeature(Feature::MacrosOnImports))
 invocationArgStrs.push_back("-D__SWIFT_ATTR_SUPPORTS_MACROS=1");

if (searchPathOpts.getSDKPath().empty()) {
 invocationArgStrs.push_back("-Xclang");
 invocationArgStrs.push_back("-nostdsysteminc");
 } else {
if (triple.isWindowsMSVCEnvironment()) {
 llvm::SmallString<261> path; // MAX_PATH + 1
 path = searchPathOpts.getSDKPath();
llvm::sys::path::append(path, "usr", "include");
llvm::sys::path::native(path);

 invocationArgStrs.push_back("-isystem");
 invocationArgStrs.push_back(std::string(path.str()));
 } else {
// On Darwin, Clang uses -isysroot to specify the include
// system root. On other targets, it seems to use --sysroot.
if (triple.isOSDarwin()) {
 invocationArgStrs.push_back("-isysroot");
 invocationArgStrs.push_back(searchPathOpts.getSDKPath().str());
 } else {
if (auto sysroot = searchPathOpts.getSysRoot()) {
 invocationArgStrs.push_back("--sysroot");
 invocationArgStrs.push_back(sysroot->str());
 } else {
 invocationArgStrs.push_back("--sysroot");
 invocationArgStrs.push_back(searchPathOpts.getSDKPath().str());
 }
 }
 }
 }

const std::string &moduleCachePath = importerOpts.ModuleCachePath;
const std::string &scannerCachePath = importerOpts.ClangScannerModuleCachePath;
// If a scanner cache is specified, this must be a scanning action. Prefer this
// path for the Clang scanner to cache its Scanning PCMs.
if (!scannerCachePath.empty()) {
 invocationArgStrs.push_back("-fmodules-cache-path=");
 invocationArgStrs.back().append(scannerCachePath);
 } elseif (!moduleCachePath.empty() && !importerOpts.DisableImplicitClangModules) {
 invocationArgStrs.push_back("-fmodules-cache-path=");
 invocationArgStrs.back().append(moduleCachePath);
 }

if (importerOpts.DisableImplicitClangModules) {
 invocationArgStrs.push_back("-fno-implicit-modules");
 invocationArgStrs.push_back("-fno-implicit-module-maps");
 }

if (ctx.SearchPathOpts.DisableModulesValidateSystemDependencies) {
 invocationArgStrs.push_back("-fno-modules-validate-system-headers");
 } else {
 invocationArgStrs.push_back("-fmodules-validate-system-headers");
 }

if (importerOpts.DetailedPreprocessingRecord) {
 invocationArgStrs.insert(invocationArgStrs.end(), {
"-Xclang", "-detailed-preprocessing-record",
"-Xclang", "-fmodule-format=raw",
 });
 } else {
 invocationArgStrs.insert(invocationArgStrs.end(), {
"-Xclang", "-fmodule-format=obj",
 });
 }

// Enable API notes alongside headers/in frameworks.
 invocationArgStrs.push_back("-fapinotes-modules");
 invocationArgStrs.push_back("-fapinotes-swift-version=" +
 languageVersion.asAPINotesVersionString());

// Prefer `-sdk` paths.
if (!searchPathOpts.getSDKPath().empty()) {
 llvm::SmallString<261> path{searchPathOpts.getSDKPath()};
llvm::sys::path::append(path, "usr", "lib", "swift", "apinotes");

 invocationArgStrs.push_back("-iapinotes-modules");
 invocationArgStrs.push_back(path.str().str());
 }

// Fallback to "legacy" `-resource-dir` paths.
 {
 llvm::SmallString<261> path{searchPathOpts.RuntimeResourcePath};
llvm::sys::path::append(path, "apinotes");

 invocationArgStrs.push_back("-iapinotes-modules");
 invocationArgStrs.push_back(path.str().str());
 }
}

staticvoid
getEmbedBitcodeInvocationArguments(std::vector<std::string> &invocationArgStrs,
 ASTContext &ctx) {
 invocationArgStrs.insert(invocationArgStrs.end(), {
// Backend mode.
"-fembed-bitcode",

// ...but Clang isn't doing the emission.
"-fsyntax-only",

"-x", "ir",
 });
}

void
importer::addCommonInvocationArguments(
 std::vector<std::string> &invocationArgStrs,
 ASTContext &ctx, bool requiresBuiltinHeadersInSystemModules,
bool ignoreClangTarget) {
using ImporterImpl = ClangImporter::Implementation;
 llvm::Triple triple = ctx.LangOpts.Target;
// Use clang specific target triple if given.
if (ctx.LangOpts.ClangTarget.has_value() && !ignoreClangTarget) {
 triple = ctx.LangOpts.ClangTarget.value();
 }
 SearchPathOptions &searchPathOpts = ctx.SearchPathOpts;
const ClangImporterOptions &importerOpts = ctx.ClangImporterOpts;

 invocationArgStrs.push_back("-target");
 invocationArgStrs.push_back(triple.str());

if (ctx.LangOpts.SDKVersion) {
 invocationArgStrs.push_back("-Xclang");
 invocationArgStrs.push_back(
"-target-sdk-version=" + ctx.LangOpts.SDKVersion->getAsString());
 }

 invocationArgStrs.push_back(ImporterImpl::moduleImportBufferName);

if (ctx.LangOpts.EnableAppExtensionRestrictions) {
 invocationArgStrs.push_back("-fapplication-extension");
 }

if (!importerOpts.TargetCPU.empty()) {
switch (triple.getArch()) {
case llvm::Triple::x86:
case llvm::Triple::x86_64:
// For x86, `-mcpu` is deprecated and an alias of `-mtune`. We need to
// pass `-march` and `-mtune` to behave like `-mcpu` on other targets.
 invocationArgStrs.push_back("-march=" + importerOpts.TargetCPU);
 invocationArgStrs.push_back("-mtune=" + importerOpts.TargetCPU);
break;
default:
 invocationArgStrs.push_back("-mcpu=" + importerOpts.TargetCPU);
break;
 }
 } elseif (triple.getArch() == llvm::Triple::systemz) {
 invocationArgStrs.push_back("-march=z13");
 }

if (triple.getArch() == llvm::Triple::x86_64) {
// Enable double wide atomic intrinsics on every x86_64 target.
// (This is the default on Darwin, but not so on other platforms.)
 invocationArgStrs.push_back("-mcx16");
 }

if (triple.isOSDarwin()) {
if (auto variantTriple = ctx.LangOpts.TargetVariant) {
// Passing the -target-variant along to clang causes clang's
// CodeGenerator to emit zippered .o files.
 invocationArgStrs.push_back("-darwin-target-variant");
if (ctx.LangOpts.ClangTargetVariant.has_value() && !ignoreClangTarget)
 variantTriple = ctx.LangOpts.ClangTargetVariant.value();
 invocationArgStrs.push_back(variantTriple->str());
 }

if (ctx.LangOpts.VariantSDKVersion) {
 invocationArgStrs.push_back("-Xclang");
 invocationArgStrs.push_back(
 ("-darwin-target-variant-sdk-version=" +
 ctx.LangOpts.VariantSDKVersion->getAsString()));
 }
 }

if (std::optional<StringRef> R = searchPathOpts.getWinSDKRoot()) {
 invocationArgStrs.emplace_back("-Xmicrosoft-windows-sdk-root");
 invocationArgStrs.emplace_back(*R);
 }
if (std::optional<StringRef> V = searchPathOpts.getWinSDKVersion()) {
 invocationArgStrs.emplace_back("-Xmicrosoft-windows-sdk-version");
 invocationArgStrs.emplace_back(*V);
 }
if (std::optional<StringRef> R = searchPathOpts.getVCToolsRoot()) {
 invocationArgStrs.emplace_back("-Xmicrosoft-visualc-tools-root");
 invocationArgStrs.emplace_back(*R);
 }
if (std::optional<StringRef> V = searchPathOpts.getVCToolsVersion()) {
 invocationArgStrs.emplace_back("-Xmicrosoft-visualc-tools-version");
 invocationArgStrs.emplace_back(*V);
 }

if (!importerOpts.Optimization.empty()) {
 invocationArgStrs.push_back(importerOpts.Optimization);
 }

const std::string &overrideResourceDir = importerOpts.OverrideResourceDir;
if (overrideResourceDir.empty()) {
 llvm::SmallString<128> resourceDir(searchPathOpts.RuntimeResourcePath);

// Adjust the path to refer to our copy of the Clang resource directory
// under 'lib/swift/clang', which is either a real resource directory or a
// symlink to one inside of a full Clang installation.
//
// The rationale for looking under the Swift resource directory and not
// assuming that the Clang resource directory is located next to it is that
// Swift, when installed separately, should not need to install files in
// directories that are not "owned" by it.
llvm::sys::path::append(resourceDir, "clang");

// Set the Clang resource directory to the path we computed.
 invocationArgStrs.push_back("-resource-dir");
 invocationArgStrs.push_back(std::string(resourceDir.str()));
 } else {
 invocationArgStrs.push_back("-resource-dir");
 invocationArgStrs.push_back(overrideResourceDir);
 }

if (!importerOpts.IndexStorePath.empty()) {
 invocationArgStrs.push_back("-index-store-path");
 invocationArgStrs.push_back(importerOpts.IndexStorePath);
 }

 invocationArgStrs.push_back("-fansi-escape-codes");

if (importerOpts.ValidateModulesOnce) {
 invocationArgStrs.push_back("-fmodules-validate-once-per-build-session");
 invocationArgStrs.push_back("-fbuild-session-file=" + importerOpts.BuildSessionFilePath);
 }

for (auto extraArg : importerOpts.ExtraArgs) {
 invocationArgStrs.push_back(extraArg);
 }

for (constauto &framepath : searchPathOpts.getFrameworkSearchPaths()) {
if (!framepath.Path.empty()) {
if (framepath.IsSystem) {
 invocationArgStrs.push_back("-iframework");
 invocationArgStrs.push_back(framepath.Path);
 } else {
 invocationArgStrs.push_back("-F" + framepath.Path);
 }
 }
 }

for (constauto &path : searchPathOpts.getImportSearchPaths()) {
if (!path.Path.empty()) {
if (path.IsSystem) {
 invocationArgStrs.push_back("-isystem");
 invocationArgStrs.push_back(path.Path);
 } else {
 invocationArgStrs.push_back("-I" + path.Path);
 }
 }
 }

for (auto &overlay : searchPathOpts.VFSOverlayFiles) {
 invocationArgStrs.push_back("-ivfsoverlay");
 invocationArgStrs.push_back(overlay);
 }

if (requiresBuiltinHeadersInSystemModules) {
 invocationArgStrs.push_back("-Xclang");
 invocationArgStrs.push_back("-fbuiltin-headers-in-system-modules");
 }
}

boolClangImporter::canReadPCH(StringRef PCHFilename) {
if (!llvm::sys::fs::exists(PCHFilename))
returnfalse;

// FIXME: The following attempts to do an initial ReadAST invocation to verify
// the PCH, without causing trouble for the existing CompilerInstance.
// Look into combining creating the ASTReader along with verification + update
// if necessary, so that we can create and use one ASTReader in the common case
// when there is no need for update.
 clang::CompilerInstance CI(Impl.Instance->getPCHContainerOperations(),
 &Impl.Instance->getModuleCache());
auto invocation =
 std::make_shared<clang::CompilerInvocation>(*Impl.Invocation);
 invocation->getPreprocessorOpts().DisablePCHOrModuleValidation =
 clang::DisableValidationForModuleKind::None;
 invocation->getHeaderSearchOpts().ModulesValidateSystemHeaders = true;
 invocation->getLangOpts().NeededByPCHOrCompilationUsesPCH = true;
 invocation->getLangOpts().CacheGeneratedPCH = true;

// ClangImporter::create adds a remapped MemoryBuffer that we don't need
// here. Moreover, it's a raw pointer owned by the preprocessor options; if
// we don't clear the range then both the original and new CompilerInvocation
// will try to free it.
 invocation->getPreprocessorOpts().RemappedFileBuffers.clear();

 CI.setInvocation(std::move(invocation));
 CI.setTarget(&Impl.Instance->getTarget());
 CI.setDiagnostics(
 &*clang::CompilerInstance::createDiagnostics(newclang::DiagnosticOptions()));

// Note: Reusing the file manager is safe; this is a component that's already
// reused when building PCM files for the module cache.
 CI.createSourceManager(Impl.Instance->getFileManager());
auto &clangSrcMgr = CI.getSourceManager();
auto FID = clangSrcMgr.createFileID(
 std::make_unique<ZeroFilledMemoryBuffer>(1, "<main>"));
 clangSrcMgr.setMainFileID(FID);
auto &diagConsumer = CI.getDiagnosticClient();
 diagConsumer.BeginSourceFile(CI.getLangOpts());
 SWIFT_DEFER {
 diagConsumer.EndSourceFile();
 };

// Pass in TU_Complete, which is the default mode for the Preprocessor
// constructor and the right one for reading a PCH.
 CI.createPreprocessor(clang::TU_Complete);
 CI.createASTContext();
 CI.createASTReader();