clang 19.0.0git
ModuleBuilder.cpp
Go to the documentation of this file.
1//===--- ModuleBuilder.cpp - Emit LLVM Code from ASTs ---------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This builds an AST and converts it to LLVM Code.
10//
11//===----------------------------------------------------------------------===//
12
14#include "CGDebugInfo.h"
15#include "CodeGenModule.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/Expr.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/IR/DataLayout.h"
24#include "llvm/IR/LLVMContext.h"
25#include "llvm/IR/Module.h"
26#include "llvm/Support/VirtualFileSystem.h"
27#include <memory>
28
29using namespace clang;
30using namespace CodeGen;
31
32namespace {
33 class CodeGeneratorImpl : public CodeGenerator {
34 DiagnosticsEngine &Diags;
35 ASTContext *Ctx;
36 IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; // Only used for debug info.
37 const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.
38 const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.
39 const CodeGenOptions &CodeGenOpts;
40
41 unsigned HandlingTopLevelDecls;
42
43 /// Use this when emitting decls to block re-entrant decl emission. It will
44 /// emit all deferred decls on scope exit. Set EmitDeferred to false if decl
45 /// emission must be deferred longer, like at the end of a tag definition.
46 struct HandlingTopLevelDeclRAII {
47 CodeGeneratorImpl &Self;
48 bool EmitDeferred;
49 HandlingTopLevelDeclRAII(CodeGeneratorImpl &Self,
50 bool EmitDeferred = true)
51 : Self(Self), EmitDeferred(EmitDeferred) {
52 ++Self.HandlingTopLevelDecls;
53 }
54 ~HandlingTopLevelDeclRAII() {
55 unsigned Level = --Self.HandlingTopLevelDecls;
56 if (Level == 0 && EmitDeferred)
57 Self.EmitDeferredDecls();
58 }
59 };
60
61 CoverageSourceInfo *CoverageInfo;
62
63 protected:
64 std::unique_ptr<llvm::Module> M;
65 std::unique_ptr<CodeGen::CodeGenModule> Builder;
66
67 private:
68 SmallVector<FunctionDecl *, 8> DeferredInlineMemberFuncDefs;
69
70 static llvm::StringRef ExpandModuleName(llvm::StringRef ModuleName,
71 const CodeGenOptions &CGO) {
72 if (ModuleName == "-" && !CGO.MainFileName.empty())
73 return CGO.MainFileName;
74 return ModuleName;
75 }
76
77 public:
78 CodeGeneratorImpl(DiagnosticsEngine &diags, llvm::StringRef ModuleName,
80 const HeaderSearchOptions &HSO,
81 const PreprocessorOptions &PPO, const CodeGenOptions &CGO,
82 llvm::LLVMContext &C,
83 CoverageSourceInfo *CoverageInfo = nullptr)
84 : Diags(diags), Ctx(nullptr), FS(std::move(FS)), HeaderSearchOpts(HSO),
85 PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0),
86 CoverageInfo(CoverageInfo),
87 M(new llvm::Module(ExpandModuleName(ModuleName, CGO), C)) {
88 C.setDiscardValueNames(CGO.DiscardValueNames);
89 }
90
91 ~CodeGeneratorImpl() override {
92 // There should normally not be any leftover inline method definitions.
93 assert(DeferredInlineMemberFuncDefs.empty() ||
94 Diags.hasErrorOccurred());
95 }
96
97 CodeGenModule &CGM() {
98 return *Builder;
99 }
100
101 llvm::Module *GetModule() {
102 return M.get();
103 }
104
105 CGDebugInfo *getCGDebugInfo() {
106 return Builder->getModuleDebugInfo();
107 }
108
109 llvm::Module *ReleaseModule() {
110 return M.release();
111 }
112
113 const Decl *GetDeclForMangledName(StringRef MangledName) {
114 GlobalDecl Result;
115 if (!Builder->lookupRepresentativeDecl(MangledName, Result))
116 return nullptr;
117 const Decl *D = Result.getCanonicalDecl().getDecl();
118 if (auto FD = dyn_cast<FunctionDecl>(D)) {
119 if (FD->hasBody(FD))
120 return FD;
121 } else if (auto TD = dyn_cast<TagDecl>(D)) {
122 if (auto Def = TD->getDefinition())
123 return Def;
124 }
125 return D;
126 }
127
128 llvm::StringRef GetMangledName(GlobalDecl GD) {
129 return Builder->getMangledName(GD);
130 }
131
132 llvm::Constant *GetAddrOfGlobal(GlobalDecl global, bool isForDefinition) {
133 return Builder->GetAddrOfGlobal(global, ForDefinition_t(isForDefinition));
134 }
135
136 llvm::Module *StartModule(llvm::StringRef ModuleName,
137 llvm::LLVMContext &C) {
138 assert(!M && "Replacing existing Module?");
139 M.reset(new llvm::Module(ExpandModuleName(ModuleName, CodeGenOpts), C));
140
141 std::unique_ptr<CodeGenModule> OldBuilder = std::move(Builder);
142
143 Initialize(*Ctx);
144
145 if (OldBuilder)
146 OldBuilder->moveLazyEmissionStates(Builder.get());
147
148 return M.get();
149 }
150
151 void Initialize(ASTContext &Context) override {
152 Ctx = &Context;
153
154 M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple());
155 M->setDataLayout(Ctx->getTargetInfo().getDataLayoutString());
156 const auto &SDKVersion = Ctx->getTargetInfo().getSDKVersion();
157 if (!SDKVersion.empty())
158 M->setSDKVersion(SDKVersion);
159 if (const auto *TVT = Ctx->getTargetInfo().getDarwinTargetVariantTriple())
160 M->setDarwinTargetVariantTriple(TVT->getTriple());
161 if (auto TVSDKVersion =
163 M->setDarwinTargetVariantSDKVersion(*TVSDKVersion);
164 Builder.reset(new CodeGen::CodeGenModule(Context, FS, HeaderSearchOpts,
165 PreprocessorOpts, CodeGenOpts,
166 *M, Diags, CoverageInfo));
167
168 for (auto &&Lib : CodeGenOpts.DependentLibraries)
169 Builder->AddDependentLib(Lib);
170 for (auto &&Opt : CodeGenOpts.LinkerOptions)
171 Builder->AppendLinkerOptions(Opt);
172 }
173
174 void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
175 if (Diags.hasErrorOccurred())
176 return;
177
178 Builder->HandleCXXStaticMemberVarInstantiation(VD);
179 }
180
181 bool HandleTopLevelDecl(DeclGroupRef DG) override {
182 // FIXME: Why not return false and abort parsing?
183 if (Diags.hasErrorOccurred())
184 return true;
185
186 HandlingTopLevelDeclRAII HandlingDecl(*this);
187
188 // Make sure to emit all elements of a Decl.
189 for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
190 Builder->EmitTopLevelDecl(*I);
191
192 return true;
193 }
194
195 void EmitDeferredDecls() {
196 if (DeferredInlineMemberFuncDefs.empty())
197 return;
198
199 // Emit any deferred inline method definitions. Note that more deferred
200 // methods may be added during this loop, since ASTConsumer callbacks
201 // can be invoked if AST inspection results in declarations being added.
202 HandlingTopLevelDeclRAII HandlingDecl(*this);
203 for (unsigned I = 0; I != DeferredInlineMemberFuncDefs.size(); ++I)
204 Builder->EmitTopLevelDecl(DeferredInlineMemberFuncDefs[I]);
205 DeferredInlineMemberFuncDefs.clear();
206 }
207
208 void HandleInlineFunctionDefinition(FunctionDecl *D) override {
209 if (Diags.hasErrorOccurred())
210 return;
211
212 assert(D->doesThisDeclarationHaveABody());
213
214 // We may want to emit this definition. However, that decision might be
215 // based on computing the linkage, and we have to defer that in case we
216 // are inside of something that will change the method's final linkage,
217 // e.g.
218 // typedef struct {
219 // void bar();
220 // void foo() { bar(); }
221 // } A;
222 DeferredInlineMemberFuncDefs.push_back(D);
223
224 // Provide some coverage mapping even for methods that aren't emitted.
225 // Don't do this for templated classes though, as they may not be
226 // instantiable.
228 Builder->AddDeferredUnusedCoverageMapping(D);
229 }
230
231 /// HandleTagDeclDefinition - This callback is invoked each time a TagDecl
232 /// to (e.g. struct, union, enum, class) is completed. This allows the
233 /// client hack on the type, which can occur at any point in the file
234 /// (because these can be defined in declspecs).
235 void HandleTagDeclDefinition(TagDecl *D) override {
236 if (Diags.hasErrorOccurred())
237 return;
238
239 // Don't allow re-entrant calls to CodeGen triggered by PCH
240 // deserialization to emit deferred decls.
241 HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);
242
243 Builder->UpdateCompletedType(D);
244
245 // For MSVC compatibility, treat declarations of static data members with
246 // inline initializers as definitions.
247 if (Ctx->getTargetInfo().getCXXABI().isMicrosoft()) {
248 for (Decl *Member : D->decls()) {
249 if (VarDecl *VD = dyn_cast<VarDecl>(Member)) {
251 Ctx->DeclMustBeEmitted(VD)) {
252 Builder->EmitGlobal(VD);
253 }
254 }
255 }
256 }
257 // For OpenMP emit declare reduction functions, if required.
258 if (Ctx->getLangOpts().OpenMP) {
259 for (Decl *Member : D->decls()) {
260 if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Member)) {
261 if (Ctx->DeclMustBeEmitted(DRD))
262 Builder->EmitGlobal(DRD);
263 } else if (auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Member)) {
264 if (Ctx->DeclMustBeEmitted(DMD))
265 Builder->EmitGlobal(DMD);
266 }
267 }
268 }
269 }
270
271 void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
272 if (Diags.hasErrorOccurred())
273 return;
274
275 // Don't allow re-entrant calls to CodeGen triggered by PCH
276 // deserialization to emit deferred decls.
277 HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);
278
279 if (CodeGen::CGDebugInfo *DI = Builder->getModuleDebugInfo())
280 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
281 DI->completeRequiredType(RD);
282 }
283
284 void HandleTranslationUnit(ASTContext &Ctx) override {
285 // Release the Builder when there is no error.
286 if (!Diags.hasErrorOccurred() && Builder)
287 Builder->Release();
288
289 // If there are errors before or when releasing the Builder, reset
290 // the module to stop here before invoking the backend.
291 if (Diags.hasErrorOccurred()) {
292 if (Builder)
293 Builder->clear();
294 M.reset();
295 return;
296 }
297 }
298
299 void AssignInheritanceModel(CXXRecordDecl *RD) override {
300 if (Diags.hasErrorOccurred())
301 return;
302
303 Builder->RefreshTypeCacheForClass(RD);
304 }
305
306 void CompleteTentativeDefinition(VarDecl *D) override {
307 if (Diags.hasErrorOccurred())
308 return;
309
310 Builder->EmitTentativeDefinition(D);
311 }
312
313 void CompleteExternalDeclaration(VarDecl *D) override {
314 Builder->EmitExternalDeclaration(D);
315 }
316
317 void HandleVTable(CXXRecordDecl *RD) override {
318 if (Diags.hasErrorOccurred())
319 return;
320
321 Builder->EmitVTable(RD);
322 }
323 };
324}
325
326void CodeGenerator::anchor() { }
327
329 return static_cast<CodeGeneratorImpl*>(this)->CGM();
330}
331
333 return static_cast<CodeGeneratorImpl*>(this)->GetModule();
334}
335
337 return static_cast<CodeGeneratorImpl*>(this)->ReleaseModule();
338}
339
341 return static_cast<CodeGeneratorImpl*>(this)->getCGDebugInfo();
342}
343
344const Decl *CodeGenerator::GetDeclForMangledName(llvm::StringRef name) {
345 return static_cast<CodeGeneratorImpl*>(this)->GetDeclForMangledName(name);
346}
347
349 return static_cast<CodeGeneratorImpl *>(this)->GetMangledName(GD);
350}
351
353 bool isForDefinition) {
354 return static_cast<CodeGeneratorImpl*>(this)
355 ->GetAddrOfGlobal(global, isForDefinition);
356}
357
358llvm::Module *CodeGenerator::StartModule(llvm::StringRef ModuleName,
359 llvm::LLVMContext &C) {
360 return static_cast<CodeGeneratorImpl*>(this)->StartModule(ModuleName, C);
361}
362
364clang::CreateLLVMCodeGen(DiagnosticsEngine &Diags, llvm::StringRef ModuleName,
366 const HeaderSearchOptions &HeaderSearchOpts,
367 const PreprocessorOptions &PreprocessorOpts,
368 const CodeGenOptions &CGO, llvm::LLVMContext &C,
369 CoverageSourceInfo *CoverageInfo) {
370 return new CodeGeneratorImpl(Diags, ModuleName, std::move(FS),
371 HeaderSearchOpts, PreprocessorOpts, CGO, C,
372 CoverageInfo);
373}
Defines the clang::ASTContext interface.
Defines the Diagnostic-related interfaces.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const
Returns true if this is an inline-initialized static data member which is treated as a definition for...
const LangOptions & getLangOpts() const
Definition: ASTContext.h:770
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:752
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::vector< std::string > DependentLibraries
A list of dependent libraries.
std::string MainFileName
The user provided name for the "main file", if non-empty.
std::vector< std::string > LinkerOptions
A list of linker options to embed in the object file.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:55
This class organizes the cross-function state that is used while generating LLVM code.
The primary public interface to the Clang code generator.
Definition: ModuleBuilder.h:48
llvm::Module * ReleaseModule()
Release ownership of the module to the caller.
const Decl * GetDeclForMangledName(llvm::StringRef MangledName)
Given a mangled name, return a declaration which mangles that way which has been added to this code g...
llvm::Module * StartModule(llvm::StringRef ModuleName, llvm::LLVMContext &C)
Create a new llvm::Module after calling HandleTranslationUnit.
llvm::Constant * GetAddrOfGlobal(GlobalDecl decl, bool isForDefinition)
Return the LLVM address of the given global entity.
llvm::StringRef GetMangledName(GlobalDecl GD)
Given a global declaration, return a mangled name for this declaration which has been added to this c...
CodeGen::CGDebugInfo * getCGDebugInfo()
Return debug info code generator.
CodeGen::CodeGenModule & CGM()
Return an opaque reference to the CodeGenModule object, which can be used in various secondary APIs.
llvm::Module * GetModule()
Return the module that this code generator is building into.
Stores additional source code information like skipped ranges which is required by the coverage mappi...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1260
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2321
iterator begin()
Definition: DeclGroup.h:99
iterator end()
Definition: DeclGroup.h:105
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:908
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:968
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
bool hasErrorOccurred() const
Definition: Diagnostic.h:843
Represents a function declaration or definition.
Definition: Decl.h:1959
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2270
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
Describes a module or submodule.
Definition: Module.h:105
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Represents a struct/union/class.
Definition: Decl.h:4133
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3549
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:136
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1219
const char * getDataLayoutString() const
Definition: TargetInfo.h:1228
const llvm::Triple * getDarwinTargetVariantTriple() const
Returns the darwin target variant triple, the variant of the deployment target for which the code is ...
Definition: TargetInfo.h:1759
const std::optional< VersionTuple > getDarwinTargetVariantSDKVersion() const
Returns the version of the darwin target variant SDK which was used during the compilation if one was...
Definition: TargetInfo.h:1765
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1290
const llvm::VersionTuple & getSDKVersion() const
Definition: TargetInfo.h:1738
Represents a variable declaration or definition.
Definition: Decl.h:918
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
CodeGenerator * CreateLLVMCodeGen(DiagnosticsEngine &Diags, llvm::StringRef ModuleName, IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS, const HeaderSearchOptions &HeaderSearchOpts, const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO, llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo=nullptr)
CreateLLVMCodeGen - Create a CodeGenerator instance.
YAML serialization mapping.
Definition: Dominators.h:30
Definition: Format.h:5304