1 //===--- ObjectFilePCHContainerOperations.cpp -----------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
11 #include "CGDebugInfo.h"
12 #include "CodeGenModule.h"
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/DeclObjC.h"
15 #include "clang/AST/Expr.h"
16 #include "clang/AST/RecursiveASTVisitor.h"
17 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Basic/TargetInfo.h"
19 #include "clang/CodeGen/BackendUtil.h"
20 #include "clang/Frontend/CodeGenOptions.h"
21 #include "clang/Frontend/CompilerInstance.h"
22 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Lex/HeaderSearch.h"
24 #include "clang/Serialization/ASTWriter.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/Bitcode/BitstreamReader.h"
27 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/LLVMContext.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/Object/COFF.h"
33 #include "llvm/Object/ObjectFile.h"
34 #include "llvm/Support/TargetRegistry.h"
35 #include <memory>
36 
37 using namespace clang;
38 
39 #define DEBUG_TYPE "pchcontainer"
40 
41 namespace {
42 class PCHContainerGenerator : public ASTConsumer {
43   DiagnosticsEngine &Diags;
44   const std::string MainFileName;
45   ASTContext *Ctx;
46   ModuleMap &MMap;
47   const HeaderSearchOptions &HeaderSearchOpts;
48   const PreprocessorOptions &PreprocessorOpts;
49   CodeGenOptions CodeGenOpts;
50   const TargetOptions TargetOpts;
51   const LangOptions LangOpts;
52   std::unique_ptr<llvm::LLVMContext> VMContext;
53   std::unique_ptr<llvm::Module> M;
54   std::unique_ptr<CodeGen::CodeGenModule> Builder;
55   raw_pwrite_stream *OS;
56   std::shared_ptr<PCHBuffer> Buffer;
57 
58   /// Visit every type and emit debug info for it.
59   struct DebugTypeVisitor : public RecursiveASTVisitor<DebugTypeVisitor> {
60     clang::CodeGen::CGDebugInfo &DI;
61     ASTContext &Ctx;
62     DebugTypeVisitor(clang::CodeGen::CGDebugInfo &DI, ASTContext &Ctx)
63         : DI(DI), Ctx(Ctx) {}
64 
65     /// Determine whether this type can be represented in DWARF.
66     static bool CanRepresent(const Type *Ty) {
67       return !Ty->isDependentType() && !Ty->isUndeducedType();
68     }
69 
70     bool VisitImportDecl(ImportDecl *D) {
71       auto *Import = cast<ImportDecl>(D);
72       if (!Import->getImportedOwningModule())
73         DI.EmitImportDecl(*Import);
74       return true;
75     }
76 
77     bool VisitTypeDecl(TypeDecl *D) {
78       QualType QualTy = Ctx.getTypeDeclType(D);
79       if (!QualTy.isNull() && CanRepresent(QualTy.getTypePtr()))
80         DI.getOrCreateStandaloneType(QualTy, D->getLocation());
81       return true;
82     }
83 
84     bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
85       QualType QualTy(D->getTypeForDecl(), 0);
86       if (!QualTy.isNull() && CanRepresent(QualTy.getTypePtr()))
87         DI.getOrCreateStandaloneType(QualTy, D->getLocation());
88       return true;
89     }
90 
91     bool VisitFunctionDecl(FunctionDecl *D) {
92       if (isa<CXXMethodDecl>(D))
93         // This is not yet supported. Constructing the `this' argument
94         // mandates a CodeGenFunction.
95         return true;
96 
97       SmallVector<QualType, 16> ArgTypes;
98       for (auto i : D->params())
99         ArgTypes.push_back(i->getType());
100       QualType RetTy = D->getReturnType();
101       QualType FnTy = Ctx.getFunctionType(RetTy, ArgTypes,
102                                           FunctionProtoType::ExtProtoInfo());
103       if (CanRepresent(FnTy.getTypePtr()))
104         DI.EmitFunctionDecl(D, D->getLocation(), FnTy);
105       return true;
106     }
107 
108     bool VisitObjCMethodDecl(ObjCMethodDecl *D) {
109       if (!D->getClassInterface())
110         return true;
111 
112       bool selfIsPseudoStrong, selfIsConsumed;
113       SmallVector<QualType, 16> ArgTypes;
114       ArgTypes.push_back(D->getSelfType(Ctx, D->getClassInterface(),
115                                         selfIsPseudoStrong, selfIsConsumed));
116       ArgTypes.push_back(Ctx.getObjCSelType());
117       for (auto i : D->params())
118         ArgTypes.push_back(i->getType());
119       QualType RetTy = D->getReturnType();
120       QualType FnTy = Ctx.getFunctionType(RetTy, ArgTypes,
121                                           FunctionProtoType::ExtProtoInfo());
122       if (CanRepresent(FnTy.getTypePtr()))
123         DI.EmitFunctionDecl(D, D->getLocation(), FnTy);
124       return true;
125     }
126   };
127 
128 public:
129   PCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName,
130                         const std::string &OutputFileName,
131                         raw_pwrite_stream *OS,
132                         std::shared_ptr<PCHBuffer> Buffer)
133       : Diags(CI.getDiagnostics()), Ctx(nullptr),
134         MMap(CI.getPreprocessor().getHeaderSearchInfo().getModuleMap()),
135         HeaderSearchOpts(CI.getHeaderSearchOpts()),
136         PreprocessorOpts(CI.getPreprocessorOpts()),
137         TargetOpts(CI.getTargetOpts()), LangOpts(CI.getLangOpts()), OS(OS),
138         Buffer(Buffer) {
139     // The debug info output isn't affected by CodeModel and
140     // ThreadModel, but the backend expects them to be nonempty.
141     CodeGenOpts.CodeModel = "default";
142     CodeGenOpts.ThreadModel = "single";
143     CodeGenOpts.DebugTypeExtRefs = true;
144     CodeGenOpts.setDebugInfo(CodeGenOptions::FullDebugInfo);
145   }
146 
147   ~PCHContainerGenerator() override = default;
148 
149   void Initialize(ASTContext &Context) override {
150     assert(!Ctx && "initialized multiple times");
151 
152     Ctx = &Context;
153     VMContext.reset(new llvm::LLVMContext());
154     M.reset(new llvm::Module(MainFileName, *VMContext));
155     M->setDataLayout(Ctx->getTargetInfo().getDataLayoutString());
156     Builder.reset(new CodeGen::CodeGenModule(
157         *Ctx, HeaderSearchOpts, PreprocessorOpts, CodeGenOpts, *M, Diags));
158     Builder->getModuleDebugInfo()->setModuleMap(MMap);
159   }
160 
161   bool HandleTopLevelDecl(DeclGroupRef D) override {
162     if (Diags.hasErrorOccurred())
163       return true;
164 
165     // Collect debug info for all decls in this group.
166     for (auto *I : D)
167       if (!I->isFromASTFile()) {
168         DebugTypeVisitor DTV(*Builder->getModuleDebugInfo(), *Ctx);
169         DTV.TraverseDecl(I);
170       }
171     return true;
172   }
173 
174   void HandleTagDeclDefinition(TagDecl *D) override {
175     if (Diags.hasErrorOccurred())
176       return;
177 
178     Builder->UpdateCompletedType(D);
179   }
180 
181   void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
182     if (Diags.hasErrorOccurred())
183       return;
184 
185     if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
186       Builder->getModuleDebugInfo()->completeRequiredType(RD);
187   }
188 
189   /// Emit a container holding the serialized AST.
190   void HandleTranslationUnit(ASTContext &Ctx) override {
191     assert(M && VMContext && Builder);
192     // Delete these on function exit.
193     std::unique_ptr<llvm::LLVMContext> VMContext = std::move(this->VMContext);
194     std::unique_ptr<llvm::Module> M = std::move(this->M);
195     std::unique_ptr<CodeGen::CodeGenModule> Builder = std::move(this->Builder);
196 
197     if (Diags.hasErrorOccurred())
198       return;
199 
200     M->setTargetTriple(Ctx.getTargetInfo().getTriple().getTriple());
201     M->setDataLayout(Ctx.getTargetInfo().getDataLayoutString());
202     Builder->getModuleDebugInfo()->setDwoId(Buffer->Signature);
203 
204     // Finalize the Builder.
205     if (Builder)
206       Builder->Release();
207 
208     // Ensure the target exists.
209     std::string Error;
210     auto Triple = Ctx.getTargetInfo().getTriple();
211     if (!llvm::TargetRegistry::lookupTarget(Triple.getTriple(), Error))
212       llvm::report_fatal_error(Error);
213 
214     // Emit the serialized Clang AST into its own section.
215     assert(Buffer->IsComplete && "serialization did not complete");
216     auto &SerializedAST = Buffer->Data;
217     auto Size = SerializedAST.size();
218     auto Int8Ty = llvm::Type::getInt8Ty(*VMContext);
219     auto *Ty = llvm::ArrayType::get(Int8Ty, Size);
220     auto *Data = llvm::ConstantDataArray::getString(
221         *VMContext, StringRef(SerializedAST.data(), Size),
222         /*AddNull=*/false);
223     auto *ASTSym = new llvm::GlobalVariable(
224         *M, Ty, /*constant*/ true, llvm::GlobalVariable::InternalLinkage, Data,
225         "__clang_ast");
226     // The on-disk hashtable needs to be aligned.
227     ASTSym->setAlignment(8);
228 
229     // Mach-O also needs a segment name.
230     if (Triple.isOSBinFormatMachO())
231       ASTSym->setSection("__CLANG,__clangast");
232     // COFF has an eight character length limit.
233     else if (Triple.isOSBinFormatCOFF())
234       ASTSym->setSection("clangast");
235     else
236       ASTSym->setSection("__clangast");
237 
238     DEBUG({
239       // Print the IR for the PCH container to the debug output.
240       llvm::SmallString<0> Buffer;
241       llvm::raw_svector_ostream OS(Buffer);
242       clang::EmitBackendOutput(Diags, CodeGenOpts, TargetOpts, LangOpts,
243                                Ctx.getTargetInfo().getDataLayoutString(),
244                                M.get(), BackendAction::Backend_EmitLL, &OS);
245       llvm::dbgs() << Buffer;
246     });
247 
248     // Use the LLVM backend to emit the pch container.
249     clang::EmitBackendOutput(Diags, CodeGenOpts, TargetOpts, LangOpts,
250                              Ctx.getTargetInfo().getDataLayoutString(),
251                              M.get(), BackendAction::Backend_EmitObj, OS);
252 
253     // Make sure the pch container hits disk.
254     OS->flush();
255 
256     // Free the memory for the temporary buffer.
257     llvm::SmallVector<char, 0> Empty;
258     SerializedAST = std::move(Empty);
259   }
260 };
261 
262 } // anonymous namespace
263 
264 std::unique_ptr<ASTConsumer>
265 ObjectFilePCHContainerWriter::CreatePCHContainerGenerator(
266     CompilerInstance &CI, const std::string &MainFileName,
267     const std::string &OutputFileName, llvm::raw_pwrite_stream *OS,
268     std::shared_ptr<PCHBuffer> Buffer) const {
269   return llvm::make_unique<PCHContainerGenerator>(CI, MainFileName,
270                                                   OutputFileName, OS, Buffer);
271 }
272 
273 void ObjectFilePCHContainerReader::ExtractPCH(
274     llvm::MemoryBufferRef Buffer, llvm::BitstreamReader &StreamFile) const {
275   if (auto OF = llvm::object::ObjectFile::createObjectFile(Buffer)) {
276     auto *Obj = OF.get().get();
277     bool IsCOFF = isa<llvm::object::COFFObjectFile>(Obj);
278     // Find the clang AST section in the container.
279     for (auto &Section : OF->get()->sections()) {
280       StringRef Name;
281       Section.getName(Name);
282       if ((!IsCOFF && Name == "__clangast") ||
283           ( IsCOFF && Name ==   "clangast")) {
284         StringRef Buf;
285         Section.getContents(Buf);
286         StreamFile.init((const unsigned char *)Buf.begin(),
287                         (const unsigned char *)Buf.end());
288         return;
289       }
290     }
291   }
292 
293   // As a fallback, treat the buffer as a raw AST.
294   StreamFile.init((const unsigned char *)Buffer.getBufferStart(),
295                   (const unsigned char *)Buffer.getBufferEnd());
296 }
297