clang  3.7.0
ModuleBuilder.cpp
Go to the documentation of this file.
1 //===--- ModuleBuilder.cpp - Emit LLVM Code from ASTs ---------------------===//
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 // This builds an AST and converts it to LLVM Code.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "CGDebugInfo.h"
16 #include "CodeGenModule.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/Basic/Diagnostic.h"
21 #include "clang/Basic/TargetInfo.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/IR/DataLayout.h"
25 #include "llvm/IR/LLVMContext.h"
26 #include "llvm/IR/Module.h"
27 #include <memory>
28 using namespace clang;
29 
30 namespace {
31  class CodeGeneratorImpl : public CodeGenerator {
32  DiagnosticsEngine &Diags;
33  std::unique_ptr<const llvm::DataLayout> TD;
34  ASTContext *Ctx;
35  const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.
36  const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.
37  const CodeGenOptions CodeGenOpts; // Intentionally copied in.
38 
39  unsigned HandlingTopLevelDecls;
40  struct HandlingTopLevelDeclRAII {
41  CodeGeneratorImpl &Self;
42  HandlingTopLevelDeclRAII(CodeGeneratorImpl &Self) : Self(Self) {
43  ++Self.HandlingTopLevelDecls;
44  }
45  ~HandlingTopLevelDeclRAII() {
46  if (--Self.HandlingTopLevelDecls == 0)
47  Self.EmitDeferredDecls();
48  }
49  };
50 
51  CoverageSourceInfo *CoverageInfo;
52 
53  protected:
54  std::unique_ptr<llvm::Module> M;
55  std::unique_ptr<CodeGen::CodeGenModule> Builder;
56 
57  private:
58  SmallVector<CXXMethodDecl *, 8> DeferredInlineMethodDefinitions;
59 
60  public:
61  CodeGeneratorImpl(DiagnosticsEngine &diags, const std::string &ModuleName,
62  const HeaderSearchOptions &HSO,
63  const PreprocessorOptions &PPO, const CodeGenOptions &CGO,
64  llvm::LLVMContext &C,
65  CoverageSourceInfo *CoverageInfo = nullptr)
66  : Diags(diags), Ctx(nullptr), HeaderSearchOpts(HSO),
67  PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0),
68  CoverageInfo(CoverageInfo),
69  M(new llvm::Module(ModuleName, C)) {}
70 
71  ~CodeGeneratorImpl() override {
72  // There should normally not be any leftover inline method definitions.
73  assert(DeferredInlineMethodDefinitions.empty() ||
74  Diags.hasErrorOccurred());
75  }
76 
77  llvm::Module* GetModule() override {
78  return M.get();
79  }
80 
81  const Decl *GetDeclForMangledName(StringRef MangledName) override {
83  if (!Builder->lookupRepresentativeDecl(MangledName, Result))
84  return nullptr;
85  const Decl *D = Result.getCanonicalDecl().getDecl();
86  if (auto FD = dyn_cast<FunctionDecl>(D)) {
87  if (FD->hasBody(FD))
88  return FD;
89  } else if (auto TD = dyn_cast<TagDecl>(D)) {
90  if (auto Def = TD->getDefinition())
91  return Def;
92  }
93  return D;
94  }
95 
96  llvm::Module *ReleaseModule() override { return M.release(); }
97 
98  void Initialize(ASTContext &Context) override {
99  Ctx = &Context;
100 
101  M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple());
102  M->setDataLayout(Ctx->getTargetInfo().getTargetDescription());
103  TD.reset(
104  new llvm::DataLayout(Ctx->getTargetInfo().getTargetDescription()));
105  Builder.reset(new CodeGen::CodeGenModule(Context,
106  HeaderSearchOpts,
107  PreprocessorOpts,
108  CodeGenOpts, *M, *TD,
109  Diags, CoverageInfo));
110 
111  for (size_t i = 0, e = CodeGenOpts.DependentLibraries.size(); i < e; ++i)
112  HandleDependentLibrary(CodeGenOpts.DependentLibraries[i]);
113  }
114 
115  void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
116  if (Diags.hasErrorOccurred())
117  return;
118 
119  Builder->HandleCXXStaticMemberVarInstantiation(VD);
120  }
121 
122  bool HandleTopLevelDecl(DeclGroupRef DG) override {
123  if (Diags.hasErrorOccurred())
124  return true;
125 
126  HandlingTopLevelDeclRAII HandlingDecl(*this);
127 
128  // Make sure to emit all elements of a Decl.
129  for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
130  Builder->EmitTopLevelDecl(*I);
131 
132  return true;
133  }
134 
135  void EmitDeferredDecls() {
136  if (DeferredInlineMethodDefinitions.empty())
137  return;
138 
139  // Emit any deferred inline method definitions. Note that more deferred
140  // methods may be added during this loop, since ASTConsumer callbacks
141  // can be invoked if AST inspection results in declarations being added.
142  HandlingTopLevelDeclRAII HandlingDecl(*this);
143  for (unsigned I = 0; I != DeferredInlineMethodDefinitions.size(); ++I)
144  Builder->EmitTopLevelDecl(DeferredInlineMethodDefinitions[I]);
145  DeferredInlineMethodDefinitions.clear();
146  }
147 
148  void HandleInlineMethodDefinition(CXXMethodDecl *D) override {
149  if (Diags.hasErrorOccurred())
150  return;
151 
152  assert(D->doesThisDeclarationHaveABody());
153 
154  // We may want to emit this definition. However, that decision might be
155  // based on computing the linkage, and we have to defer that in case we
156  // are inside of something that will change the method's final linkage,
157  // e.g.
158  // typedef struct {
159  // void bar();
160  // void foo() { bar(); }
161  // } A;
162  DeferredInlineMethodDefinitions.push_back(D);
163 
164  // Provide some coverage mapping even for methods that aren't emitted.
165  // Don't do this for templated classes though, as they may not be
166  // instantiable.
168  Builder->AddDeferredUnusedCoverageMapping(D);
169  }
170 
171  /// HandleTagDeclDefinition - This callback is invoked each time a TagDecl
172  /// to (e.g. struct, union, enum, class) is completed. This allows the
173  /// client hack on the type, which can occur at any point in the file
174  /// (because these can be defined in declspecs).
175  void HandleTagDeclDefinition(TagDecl *D) override {
176  if (Diags.hasErrorOccurred())
177  return;
178 
179  Builder->UpdateCompletedType(D);
180 
181  // For MSVC compatibility, treat declarations of static data members with
182  // inline initializers as definitions.
183  if (Ctx->getLangOpts().MSVCCompat) {
184  for (Decl *Member : D->decls()) {
185  if (VarDecl *VD = dyn_cast<VarDecl>(Member)) {
186  if (Ctx->isMSStaticDataMemberInlineDefinition(VD) &&
187  Ctx->DeclMustBeEmitted(VD)) {
188  Builder->EmitGlobal(VD);
189  }
190  }
191  }
192  }
193  }
194 
195  void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
196  if (Diags.hasErrorOccurred())
197  return;
198 
199  if (CodeGen::CGDebugInfo *DI = Builder->getModuleDebugInfo())
200  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
201  DI->completeRequiredType(RD);
202  }
203 
204  void HandleTranslationUnit(ASTContext &Ctx) override {
205  if (Diags.hasErrorOccurred()) {
206  if (Builder)
207  Builder->clear();
208  M.reset();
209  return;
210  }
211 
212  if (Builder)
213  Builder->Release();
214  }
215 
216  void CompleteTentativeDefinition(VarDecl *D) override {
217  if (Diags.hasErrorOccurred())
218  return;
219 
220  Builder->EmitTentativeDefinition(D);
221  }
222 
223  void HandleVTable(CXXRecordDecl *RD) override {
224  if (Diags.hasErrorOccurred())
225  return;
226 
227  Builder->EmitVTable(RD);
228  }
229 
230  void HandleLinkerOptionPragma(llvm::StringRef Opts) override {
231  Builder->AppendLinkerOptions(Opts);
232  }
233 
234  void HandleDetectMismatch(llvm::StringRef Name,
235  llvm::StringRef Value) override {
236  Builder->AddDetectMismatch(Name, Value);
237  }
238 
239  void HandleDependentLibrary(llvm::StringRef Lib) override {
240  Builder->AddDependentLib(Lib);
241  }
242  };
243 }
244 
245 void CodeGenerator::anchor() { }
246 
248  DiagnosticsEngine &Diags, const std::string &ModuleName,
249  const HeaderSearchOptions &HeaderSearchOpts,
250  const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO,
251  llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo) {
252  return new CodeGeneratorImpl(Diags, ModuleName, HeaderSearchOpts,
253  PreprocessorOpts, CGO, C, CoverageInfo);
254 }
Defines the clang::ASTContext interface.
decl_range decls() const
Definition: DeclBase.h:1413
iterator end()
Definition: DeclGroup.h:109
Stores additional source code information like skipped ranges which is required by the coverage mappi...
GlobalDecl getCanonicalDecl() const
Definition: GlobalDecl.h:52
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
const Decl * getDecl() const
Definition: GlobalDecl.h:60
Describes a module or submodule.
Definition: Basic/Module.h:49
const CXXRecordDecl * getParent() const
Definition: DeclCXX.h:1817
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:135
iterator begin()
Definition: DeclGroup.h:103
ASTContext * Context
The result type of a method or function.
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.h:1367
bool doesThisDeclarationHaveABody() const
Definition: Decl.h:1773
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2694
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
Defines the Diagnostic-related interfaces.
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
BoundNodesTreeBuilder *const Builder
CodeGenerator * CreateLLVMCodeGen(DiagnosticsEngine &Diags, const std::string &ModuleName, const HeaderSearchOptions &HeaderSearchOpts, const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO, llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo=nullptr)
Defines the clang::TargetInfo interface.