| //===--- ObjectFilePCHContainerWriter.cpp -----------------------------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/CodeGen/ObjectFilePCHContainerWriter.h" | |
| #include "CGDebugInfo.h" | |
| #include "CodeGenModule.h" | |
| #include "clang/AST/ASTContext.h" | |
| #include "clang/AST/DeclObjC.h" | |
| #include "clang/AST/Expr.h" | |
| #include "clang/AST/RecursiveASTVisitor.h" | |
| #include "clang/Basic/CodeGenOptions.h" | |
| #include "clang/Basic/Diagnostic.h" | |
| #include "clang/Basic/TargetInfo.h" | |
| #include "clang/CodeGen/BackendUtil.h" | |
| #include "clang/Frontend/CompilerInstance.h" | |
| #include "clang/Lex/HeaderSearch.h" | |
| #include "clang/Lex/Preprocessor.h" | |
| #include "llvm/ADT/StringRef.h" | |
| #include "llvm/IR/Constants.h" | |
| #include "llvm/IR/DataLayout.h" | |
| #include "llvm/IR/LLVMContext.h" | |
| #include "llvm/IR/Module.h" | |
| #include "llvm/MC/TargetRegistry.h" | |
| #include "llvm/Object/COFF.h" | |
| #include "llvm/Support/Path.h" | |
| #include <memory> | |
| #include <utility> | |
| using namespace clang; | |
| #define DEBUG_TYPE "pchcontainer" | |
| namespace { | |
| class PCHContainerGenerator : public ASTConsumer { | |
| CompilerInstance &CI; | |
| DiagnosticsEngine &Diags; | |
| const std::string MainFileName; | |
| const std::string OutputFileName; | |
| ASTContext *Ctx; | |
| ModuleMap &MMap; | |
| IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; | |
| const HeaderSearchOptions &HeaderSearchOpts; | |
| const PreprocessorOptions &PreprocessorOpts; | |
| CodeGenOptions CodeGenOpts; | |
| const TargetOptions TargetOpts; | |
| LangOptions LangOpts; | |
| std::unique_ptr<llvm::LLVMContext> VMContext; | |
| std::unique_ptr<llvm::Module> M; | |
| std::unique_ptr<CodeGen::CodeGenModule> Builder; | |
| std::unique_ptr<raw_pwrite_stream> OS; | |
| std::shared_ptr<PCHBuffer> Buffer; | |
| /// Visit every type and emit debug info for it. | |
| struct DebugTypeVisitor : public RecursiveASTVisitor<DebugTypeVisitor> { | |
| clang::CodeGen::CGDebugInfo &DI; | |
| ASTContext &Ctx; | |
| DebugTypeVisitor(clang::CodeGen::CGDebugInfo &DI, ASTContext &Ctx) | |
| : DI(DI), Ctx(Ctx) {} | |
| /// Determine whether this type can be represented in DWARF. | |
| static bool CanRepresent(const Type *Ty) { | |
| return !Ty->isDependentType() && !Ty->isUndeducedType(); | |
| } | |
| bool VisitImportDecl(ImportDecl *D) { | |
| if (!D->getImportedOwningModule()) | |
| DI.EmitImportDecl(*D); | |
| return true; | |
| } | |
| bool VisitTypeDecl(TypeDecl *D) { | |
| // TagDecls may be deferred until after all decls have been merged and we | |
| // know the complete type. Pure forward declarations will be skipped, but | |
| // they don't need to be emitted into the module anyway. | |
| if (auto *TD = dyn_cast<TagDecl>(D)) | |
| if (!TD->isCompleteDefinition()) | |
| return true; | |
| if (D->hasAttr<NoDebugAttr>()) | |
| return true; | |
| QualType QualTy = Ctx.getTypeDeclType(D); | |
| if (!QualTy.isNull() && CanRepresent(QualTy.getTypePtr())) | |
| DI.getOrCreateStandaloneType(QualTy, D->getLocation()); | |
| return true; | |
| } | |
| bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { | |
| QualType QualTy(D->getTypeForDecl(), 0); | |
| if (!QualTy.isNull() && CanRepresent(QualTy.getTypePtr())) | |
| DI.getOrCreateStandaloneType(QualTy, D->getLocation()); | |
| return true; | |
| } | |
| bool VisitFunctionDecl(FunctionDecl *D) { | |
| // Skip deduction guides. | |
| if (isa<CXXDeductionGuideDecl>(D)) | |
| return true; | |
| if (isa<CXXMethodDecl>(D)) | |
| // This is not yet supported. Constructing the `this' argument | |
| // mandates a CodeGenFunction. | |
| return true; | |
| SmallVector<QualType, 16> ArgTypes; | |
| for (auto *i : D->parameters()) | |
| ArgTypes.push_back(i->getType()); | |
| QualType RetTy = D->getReturnType(); | |
| QualType FnTy = Ctx.getFunctionType(RetTy, ArgTypes, | |
| FunctionProtoType::ExtProtoInfo()); | |
| if (CanRepresent(FnTy.getTypePtr())) | |
| DI.EmitFunctionDecl(D, D->getLocation(), FnTy); | |
| return true; | |
| } | |
| bool VisitObjCMethodDecl(ObjCMethodDecl *D) { | |
| if (!D->getClassInterface()) | |
| return true; | |
| bool selfIsPseudoStrong, selfIsConsumed; | |
| SmallVector<QualType, 16> ArgTypes; | |
| ArgTypes.push_back(D->getSelfType(Ctx, D->getClassInterface(), | |
| selfIsPseudoStrong, selfIsConsumed)); | |
| ArgTypes.push_back(Ctx.getObjCSelType()); | |
| for (auto *i : D->parameters()) | |
| ArgTypes.push_back(i->getType()); | |
| QualType RetTy = D->getReturnType(); | |
| QualType FnTy = Ctx.getFunctionType(RetTy, ArgTypes, | |
| FunctionProtoType::ExtProtoInfo()); | |
| if (CanRepresent(FnTy.getTypePtr())) | |
| DI.EmitFunctionDecl(D, D->getLocation(), FnTy); | |
| return true; | |
| } | |
| }; | |
| public: | |
| PCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName, | |
| const std::string &OutputFileName, | |
| std::unique_ptr<raw_pwrite_stream> OS, | |
| std::shared_ptr<PCHBuffer> Buffer) | |
| : CI(CI), Diags(CI.getDiagnostics()), MainFileName(MainFileName), | |
| OutputFileName(OutputFileName), Ctx(nullptr), | |
| MMap(CI.getPreprocessor().getHeaderSearchInfo().getModuleMap()), | |
| FS(CI.getVirtualFileSystemPtr()), | |
| HeaderSearchOpts(CI.getHeaderSearchOpts()), | |
| PreprocessorOpts(CI.getPreprocessorOpts()), | |
| TargetOpts(CI.getTargetOpts()), LangOpts(CI.getLangOpts()), | |
| OS(std::move(OS)), Buffer(std::move(Buffer)) { | |
| // The debug info output isn't affected by CodeModel and | |
| // ThreadModel, but the backend expects them to be nonempty. | |
| CodeGenOpts.CodeModel = "default"; | |
| LangOpts.setThreadModel(LangOptions::ThreadModelKind::Single); | |
| CodeGenOpts.DebugTypeExtRefs = true; | |
| // When building a module MainFileName is the name of the modulemap file. | |
| CodeGenOpts.MainFileName = | |
| LangOpts.CurrentModule.empty() ? MainFileName : LangOpts.CurrentModule; | |
| CodeGenOpts.setDebugInfo(llvm::codegenoptions::FullDebugInfo); | |
| CodeGenOpts.setDebuggerTuning(CI.getCodeGenOpts().getDebuggerTuning()); | |
| CodeGenOpts.DwarfVersion = CI.getCodeGenOpts().DwarfVersion; | |
| CodeGenOpts.DebugCompilationDir = | |
| CI.getInvocation().getCodeGenOpts().DebugCompilationDir; | |
| CodeGenOpts.DebugPrefixMap = | |
| CI.getInvocation().getCodeGenOpts().DebugPrefixMap; | |
| CodeGenOpts.DebugStrictDwarf = CI.getCodeGenOpts().DebugStrictDwarf; | |
| } | |
| ~PCHContainerGenerator() override = default; | |
| void Initialize(ASTContext &Context) override { | |
| assert(!Ctx && "initialized multiple times"); | |
| Ctx = &Context; | |
| VMContext.reset(new llvm::LLVMContext()); | |
| M.reset(new llvm::Module(MainFileName, *VMContext)); | |
| M->setDataLayout(Ctx->getTargetInfo().getDataLayoutString()); | |
| Builder.reset(new CodeGen::CodeGenModule( | |
| *Ctx, FS, HeaderSearchOpts, PreprocessorOpts, CodeGenOpts, *M, Diags)); | |
| // Prepare CGDebugInfo to emit debug info for a clang module. | |
| auto *DI = Builder->getModuleDebugInfo(); | |
| StringRef ModuleName = llvm::sys::path::filename(MainFileName); | |
| DI->setPCHDescriptor( | |
| {ModuleName, "", OutputFileName, ASTFileSignature::createDISentinel()}); | |
| DI->setModuleMap(MMap); | |
| } | |
| bool HandleTopLevelDecl(DeclGroupRef D) override { | |
| if (Diags.hasErrorOccurred()) | |
| return true; | |
| // Collect debug info for all decls in this group. | |
| for (auto *I : D) | |
| if (!I->isFromASTFile()) { | |
| DebugTypeVisitor DTV(*Builder->getModuleDebugInfo(), *Ctx); | |
| DTV.TraverseDecl(I); | |
| } | |
| return true; | |
| } | |
| void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override { | |
| HandleTopLevelDecl(D); | |
| } | |
| void HandleTagDeclDefinition(TagDecl *D) override { | |
| if (Diags.hasErrorOccurred()) | |
| return; | |
| if (D->isFromASTFile()) | |
| return; | |
| // Anonymous tag decls are deferred until we are building their declcontext. | |
| if (D->getName().empty()) | |
| return; | |
| // Defer tag decls until their declcontext is complete. | |
| auto *DeclCtx = D->getDeclContext(); | |
| while (DeclCtx) { | |
| if (auto *D = dyn_cast<TagDecl>(DeclCtx)) | |
| if (!D->isCompleteDefinition()) | |
| return; | |
| DeclCtx = DeclCtx->getParent(); | |
| } | |
| DebugTypeVisitor DTV(*Builder->getModuleDebugInfo(), *Ctx); | |
| DTV.TraverseDecl(D); | |
| Builder->UpdateCompletedType(D); | |
| } | |
| void HandleTagDeclRequiredDefinition(const TagDecl *D) override { | |
| if (Diags.hasErrorOccurred()) | |
| return; | |
| if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) | |
| Builder->getModuleDebugInfo()->completeRequiredType(RD); | |
| } | |
| void HandleImplicitImportDecl(ImportDecl *D) override { | |
| if (!D->getImportedOwningModule()) | |
| Builder->getModuleDebugInfo()->EmitImportDecl(*D); | |
| } | |
| /// Emit a container holding the serialized AST. | |
| void HandleTranslationUnit(ASTContext &Ctx) override { | |
| assert(M && VMContext && Builder); | |
| // Delete these on function exit. | |
| std::unique_ptr<llvm::LLVMContext> VMContext = std::move(this->VMContext); | |
| std::unique_ptr<llvm::Module> M = std::move(this->M); | |
| std::unique_ptr<CodeGen::CodeGenModule> Builder = std::move(this->Builder); | |
| if (Diags.hasErrorOccurred()) | |
| return; | |
| M->setTargetTriple(Ctx.getTargetInfo().getTriple()); | |
| M->setDataLayout(Ctx.getTargetInfo().getDataLayoutString()); | |
| // PCH files don't have a signature field in the control block, | |
| // but LLVM detects DWO CUs by looking for a non-zero DWO id. | |
| // We use the lower 64 bits for debug info. | |
| uint64_t Signature = | |
| Buffer->Signature ? Buffer->Signature.truncatedValue() : ~1ULL; | |
| Builder->getModuleDebugInfo()->setDwoId(Signature); | |
| // Finalize the Builder. | |
| if (Builder) | |
| Builder->Release(); | |
| // Ensure the target exists. | |
| std::string Error; | |
| auto Triple = Ctx.getTargetInfo().getTriple(); | |
| if (!llvm::TargetRegistry::lookupTarget(Triple, Error)) | |
| llvm::report_fatal_error(llvm::Twine(Error)); | |
| // Emit the serialized Clang AST into its own section. | |
| assert(Buffer->IsComplete && "serialization did not complete"); | |
| auto &SerializedAST = Buffer->Data; | |
| auto Size = SerializedAST.size(); | |
| if (Triple.isOSBinFormatWasm()) { | |
| // Emit __clangast in custom section instead of named data segment | |
| // to find it while iterating sections. | |
| // This could be avoided if all data segements (the wasm sense) were | |
| // represented as their own sections (in the llvm sense). | |
| // TODO: https://github.com/WebAssembly/tool-conventions/issues/138 | |
| llvm::NamedMDNode *MD = | |
| M->getOrInsertNamedMetadata("wasm.custom_sections"); | |
| llvm::Metadata *Ops[2] = { | |
| llvm::MDString::get(*VMContext, "__clangast"), | |
| llvm::MDString::get(*VMContext, | |
| StringRef(SerializedAST.data(), Size))}; | |
| auto *NameAndContent = llvm::MDTuple::get(*VMContext, Ops); | |
| MD->addOperand(NameAndContent); | |
| } else { | |
| // Emit the serialized AST into a named section via llvm.raw.sections | |
| // metadata, which the AsmPrinter emits directly at the MC layer. | |
| // This avoids IR-level size constraints from the target's address space. | |
| llvm::NamedMDNode *RawSections = | |
| M->getOrInsertNamedMetadata("llvm.raw.sections"); | |
| StringRef SectionName; | |
| if (Triple.isOSBinFormatMachO()) | |
| SectionName = "__CLANG,__clangast"; | |
| else if (Triple.isOSBinFormatCOFF()) | |
| SectionName = "clangast"; | |
| else | |
| SectionName = "__clangast"; | |
| auto *Int32Ty = llvm::Type::getInt32Ty(*VMContext); | |
| llvm::Metadata *Ops[] = { | |
| llvm::MDString::get(*VMContext, SectionName), | |
| llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(Int32Ty, 8)), | |
| llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(Int32Ty, 0)), | |
| llvm::MDString::get(*VMContext, | |
| StringRef(SerializedAST.data(), Size))}; | |
| RawSections->addOperand(llvm::MDTuple::get(*VMContext, Ops)); | |
| } | |
| LLVM_DEBUG({ | |
| // Print the IR for the PCH container to the debug output. | |
| llvm::SmallString<0> Buffer; | |
| clang::emitBackendOutput( | |
| CI, CodeGenOpts, M.get(), BackendAction::Backend_EmitLL, FS, | |
| std::make_unique<llvm::raw_svector_ostream>(Buffer)); | |
| llvm::dbgs() << Buffer; | |
| }); | |
| // Use the LLVM backend to emit the pch container. | |
| clang::emitBackendOutput(CI, CodeGenOpts, M.get(), | |
| BackendAction::Backend_EmitObj, FS, std::move(OS)); | |
| // Free the memory for the temporary buffer. | |
| llvm::SmallVector<char, 0> Empty; | |
| SerializedAST = std::move(Empty); | |
| } | |
| }; | |
| } // anonymous namespace | |
| std::unique_ptr<ASTConsumer> | |
| ObjectFilePCHContainerWriter::CreatePCHContainerGenerator( | |
| CompilerInstance &CI, const std::string &MainFileName, | |
| const std::string &OutputFileName, | |
| std::unique_ptr<llvm::raw_pwrite_stream> OS, | |
| std::shared_ptr<PCHBuffer> Buffer) const { | |
| return std::make_unique<PCHContainerGenerator>( | |
| CI, MainFileName, OutputFileName, std::move(OS), Buffer); | |
| } |