Bug Summary

File:tools/clang/lib/CodeGen/CodeGenAction.cpp
Warning:line 574, column 5
2nd function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CodeGenAction.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-7~svn337204/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn337204/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/tools/clang/lib/CodeGen -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-17-043059-5239-1 -x c++ /build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp
1//===--- CodeGenAction.cpp - LLVM Code Generation Frontend Action ---------===//
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/CodeGenAction.h"
11#include "CodeGenModule.h"
12#include "CoverageMappingGen.h"
13#include "MacroPPCallbacks.h"
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/DeclGroup.h"
18#include "clang/Basic/FileManager.h"
19#include "clang/Basic/SourceManager.h"
20#include "clang/Basic/TargetInfo.h"
21#include "clang/CodeGen/BackendUtil.h"
22#include "clang/CodeGen/ModuleBuilder.h"
23#include "clang/Frontend/CompilerInstance.h"
24#include "clang/Frontend/FrontendDiagnostic.h"
25#include "clang/Lex/Preprocessor.h"
26#include "llvm/Bitcode/BitcodeReader.h"
27#include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
28#include "llvm/IR/DebugInfo.h"
29#include "llvm/IR/DiagnosticInfo.h"
30#include "llvm/IR/DiagnosticPrinter.h"
31#include "llvm/IR/GlobalValue.h"
32#include "llvm/IR/LLVMContext.h"
33#include "llvm/IR/Module.h"
34#include "llvm/IRReader/IRReader.h"
35#include "llvm/Linker/Linker.h"
36#include "llvm/Pass.h"
37#include "llvm/Support/MemoryBuffer.h"
38#include "llvm/Support/SourceMgr.h"
39#include "llvm/Support/Timer.h"
40#include "llvm/Support/ToolOutputFile.h"
41#include "llvm/Support/YAMLTraits.h"
42#include "llvm/Transforms/IPO/Internalize.h"
43
44#include <memory>
45using namespace clang;
46using namespace llvm;
47
48namespace clang {
49 class BackendConsumer;
50 class ClangDiagnosticHandler final : public DiagnosticHandler {
51 public:
52 ClangDiagnosticHandler(const CodeGenOptions &CGOpts, BackendConsumer *BCon)
53 : CodeGenOpts(CGOpts), BackendCon(BCon) {}
54
55 bool handleDiagnostics(const DiagnosticInfo &DI) override;
56
57 bool isAnalysisRemarkEnabled(StringRef PassName) const override {
58 return (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
59 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(PassName));
60 }
61 bool isMissedOptRemarkEnabled(StringRef PassName) const override {
62 return (CodeGenOpts.OptimizationRemarkMissedPattern &&
63 CodeGenOpts.OptimizationRemarkMissedPattern->match(PassName));
64 }
65 bool isPassedOptRemarkEnabled(StringRef PassName) const override {
66 return (CodeGenOpts.OptimizationRemarkPattern &&
67 CodeGenOpts.OptimizationRemarkPattern->match(PassName));
68 }
69
70 bool isAnyRemarkEnabled() const override {
71 return (CodeGenOpts.OptimizationRemarkAnalysisPattern ||
72 CodeGenOpts.OptimizationRemarkMissedPattern ||
73 CodeGenOpts.OptimizationRemarkPattern);
74 }
75
76 private:
77 const CodeGenOptions &CodeGenOpts;
78 BackendConsumer *BackendCon;
79 };
80
81 class BackendConsumer : public ASTConsumer {
82 using LinkModule = CodeGenAction::LinkModule;
83
84 virtual void anchor();
85 DiagnosticsEngine &Diags;
86 BackendAction Action;
87 const HeaderSearchOptions &HeaderSearchOpts;
88 const CodeGenOptions &CodeGenOpts;
89 const TargetOptions &TargetOpts;
90 const LangOptions &LangOpts;
91 std::unique_ptr<raw_pwrite_stream> AsmOutStream;
92 ASTContext *Context;
93
94 Timer LLVMIRGeneration;
95 unsigned LLVMIRGenerationRefCount;
96
97 /// True if we've finished generating IR. This prevents us from generating
98 /// additional LLVM IR after emitting output in HandleTranslationUnit. This
99 /// can happen when Clang plugins trigger additional AST deserialization.
100 bool IRGenFinished = false;
101
102 std::unique_ptr<CodeGenerator> Gen;
103
104 SmallVector<LinkModule, 4> LinkModules;
105
106 // This is here so that the diagnostic printer knows the module a diagnostic
107 // refers to.
108 llvm::Module *CurLinkModule = nullptr;
109
110 public:
111 BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
112 const HeaderSearchOptions &HeaderSearchOpts,
113 const PreprocessorOptions &PPOpts,
114 const CodeGenOptions &CodeGenOpts,
115 const TargetOptions &TargetOpts,
116 const LangOptions &LangOpts, bool TimePasses,
117 const std::string &InFile,
118 SmallVector<LinkModule, 4> LinkModules,
119 std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
120 CoverageSourceInfo *CoverageInfo = nullptr)
121 : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
122 CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
123 AsmOutStream(std::move(OS)), Context(nullptr),
124 LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
125 LLVMIRGenerationRefCount(0),
126 Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts,
127 CodeGenOpts, C, CoverageInfo)),
128 LinkModules(std::move(LinkModules)) {
129 FrontendTimesIsEnabled = TimePasses;
130 }
131 llvm::Module *getModule() const { return Gen->GetModule(); }
132 std::unique_ptr<llvm::Module> takeModule() {
133 return std::unique_ptr<llvm::Module>(Gen->ReleaseModule());
134 }
135
136 CodeGenerator *getCodeGenerator() { return Gen.get(); }
137
138 void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
139 Gen->HandleCXXStaticMemberVarInstantiation(VD);
140 }
141
142 void Initialize(ASTContext &Ctx) override {
143 assert(!Context && "initialized multiple times")(static_cast <bool> (!Context && "initialized multiple times"
) ? void (0) : __assert_fail ("!Context && \"initialized multiple times\""
, "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 143, __extension__ __PRETTY_FUNCTION__))
;
144
145 Context = &Ctx;
146
147 if (FrontendTimesIsEnabled)
148 LLVMIRGeneration.startTimer();
149
150 Gen->Initialize(Ctx);
151
152 if (FrontendTimesIsEnabled)
153 LLVMIRGeneration.stopTimer();
154 }
155
156 bool HandleTopLevelDecl(DeclGroupRef D) override {
157 PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(),
158 Context->getSourceManager(),
159 "LLVM IR generation of declaration");
160
161 // Recurse.
162 if (FrontendTimesIsEnabled) {
163 LLVMIRGenerationRefCount += 1;
164 if (LLVMIRGenerationRefCount == 1)
165 LLVMIRGeneration.startTimer();
166 }
167
168 Gen->HandleTopLevelDecl(D);
169
170 if (FrontendTimesIsEnabled) {
171 LLVMIRGenerationRefCount -= 1;
172 if (LLVMIRGenerationRefCount == 0)
173 LLVMIRGeneration.stopTimer();
174 }
175
176 return true;
177 }
178
179 void HandleInlineFunctionDefinition(FunctionDecl *D) override {
180 PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
181 Context->getSourceManager(),
182 "LLVM IR generation of inline function");
183 if (FrontendTimesIsEnabled)
184 LLVMIRGeneration.startTimer();
185
186 Gen->HandleInlineFunctionDefinition(D);
187
188 if (FrontendTimesIsEnabled)
189 LLVMIRGeneration.stopTimer();
190 }
191
192 void HandleInterestingDecl(DeclGroupRef D) override {
193 // Ignore interesting decls from the AST reader after IRGen is finished.
194 if (!IRGenFinished)
195 HandleTopLevelDecl(D);
196 }
197
198 // Links each entry in LinkModules into our module. Returns true on error.
199 bool LinkInModules() {
200 for (auto &LM : LinkModules) {
201 if (LM.PropagateAttrs)
202 for (Function &F : *LM.Module)
203 Gen->CGM().AddDefaultFnAttrs(F);
204
205 CurLinkModule = LM.Module.get();
206
207 bool Err;
208 if (LM.Internalize) {
209 Err = Linker::linkModules(
210 *getModule(), std::move(LM.Module), LM.LinkFlags,
211 [](llvm::Module &M, const llvm::StringSet<> &GVS) {
212 internalizeModule(M, [&GVS](const llvm::GlobalValue &GV) {
213 return !GV.hasName() || (GVS.count(GV.getName()) == 0);
214 });
215 });
216 } else {
217 Err = Linker::linkModules(*getModule(), std::move(LM.Module),
218 LM.LinkFlags);
219 }
220
221 if (Err)
222 return true;
223 }
224 return false; // success
225 }
226
227 void HandleTranslationUnit(ASTContext &C) override {
228 {
229 PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
230 if (FrontendTimesIsEnabled) {
231 LLVMIRGenerationRefCount += 1;
232 if (LLVMIRGenerationRefCount == 1)
233 LLVMIRGeneration.startTimer();
234 }
235
236 Gen->HandleTranslationUnit(C);
237
238 if (FrontendTimesIsEnabled) {
239 LLVMIRGenerationRefCount -= 1;
240 if (LLVMIRGenerationRefCount == 0)
241 LLVMIRGeneration.stopTimer();
242 }
243
244 IRGenFinished = true;
245 }
246
247 // Silently ignore if we weren't initialized for some reason.
248 if (!getModule())
249 return;
250
251 // Install an inline asm handler so that diagnostics get printed through
252 // our diagnostics hooks.
253 LLVMContext &Ctx = getModule()->getContext();
254 LLVMContext::InlineAsmDiagHandlerTy OldHandler =
255 Ctx.getInlineAsmDiagnosticHandler();
256 void *OldContext = Ctx.getInlineAsmDiagnosticContext();
257 Ctx.setInlineAsmDiagnosticHandler(InlineAsmDiagHandler, this);
258
259 std::unique_ptr<DiagnosticHandler> OldDiagnosticHandler =
260 Ctx.getDiagnosticHandler();
261 Ctx.setDiagnosticHandler(llvm::make_unique<ClangDiagnosticHandler>(
262 CodeGenOpts, this));
263 Ctx.setDiagnosticsHotnessRequested(CodeGenOpts.DiagnosticsWithHotness);
264 if (CodeGenOpts.DiagnosticsHotnessThreshold != 0)
265 Ctx.setDiagnosticsHotnessThreshold(
266 CodeGenOpts.DiagnosticsHotnessThreshold);
267
268 std::unique_ptr<llvm::ToolOutputFile> OptRecordFile;
269 if (!CodeGenOpts.OptRecordFile.empty()) {
270 std::error_code EC;
271 OptRecordFile = llvm::make_unique<llvm::ToolOutputFile>(
272 CodeGenOpts.OptRecordFile, EC, sys::fs::F_None);
273 if (EC) {
274 Diags.Report(diag::err_cannot_open_file) <<
275 CodeGenOpts.OptRecordFile << EC.message();
276 return;
277 }
278
279 Ctx.setDiagnosticsOutputFile(
280 llvm::make_unique<yaml::Output>(OptRecordFile->os()));
281
282 if (CodeGenOpts.getProfileUse() != CodeGenOptions::ProfileNone)
283 Ctx.setDiagnosticsHotnessRequested(true);
284 }
285
286 // Link each LinkModule into our module.
287 if (LinkInModules())
288 return;
289
290 EmbedBitcode(getModule(), CodeGenOpts, llvm::MemoryBufferRef());
291
292 EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts,
293 LangOpts, C.getTargetInfo().getDataLayout(),
294 getModule(), Action, std::move(AsmOutStream));
295
296 Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);
297
298 Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));
299
300 if (OptRecordFile)
301 OptRecordFile->keep();
302 }
303
304 void HandleTagDeclDefinition(TagDecl *D) override {
305 PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
306 Context->getSourceManager(),
307 "LLVM IR generation of declaration");
308 Gen->HandleTagDeclDefinition(D);
309 }
310
311 void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
312 Gen->HandleTagDeclRequiredDefinition(D);
313 }
314
315 void CompleteTentativeDefinition(VarDecl *D) override {
316 Gen->CompleteTentativeDefinition(D);
317 }
318
319 void AssignInheritanceModel(CXXRecordDecl *RD) override {
320 Gen->AssignInheritanceModel(RD);
321 }
322
323 void HandleVTable(CXXRecordDecl *RD) override {
324 Gen->HandleVTable(RD);
325 }
326
327 static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context,
328 unsigned LocCookie) {
329 SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie);
330 ((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc);
331 }
332
333 /// Get the best possible source location to represent a diagnostic that
334 /// may have associated debug info.
335 const FullSourceLoc
336 getBestLocationFromDebugLoc(const llvm::DiagnosticInfoWithLocationBase &D,
337 bool &BadDebugInfo, StringRef &Filename,
338 unsigned &Line, unsigned &Column) const;
339
340 void InlineAsmDiagHandler2(const llvm::SMDiagnostic &,
341 SourceLocation LocCookie);
342
343 void DiagnosticHandlerImpl(const llvm::DiagnosticInfo &DI);
344 /// Specialized handler for InlineAsm diagnostic.
345 /// \return True if the diagnostic has been successfully reported, false
346 /// otherwise.
347 bool InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D);
348 /// Specialized handler for StackSize diagnostic.
349 /// \return True if the diagnostic has been successfully reported, false
350 /// otherwise.
351 bool StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D);
352 /// Specialized handler for unsupported backend feature diagnostic.
353 void UnsupportedDiagHandler(const llvm::DiagnosticInfoUnsupported &D);
354 /// Specialized handlers for optimization remarks.
355 /// Note that these handlers only accept remarks and they always handle
356 /// them.
357 void EmitOptimizationMessage(const llvm::DiagnosticInfoOptimizationBase &D,
358 unsigned DiagID);
359 void
360 OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationBase &D);
361 void OptimizationRemarkHandler(
362 const llvm::OptimizationRemarkAnalysisFPCommute &D);
363 void OptimizationRemarkHandler(
364 const llvm::OptimizationRemarkAnalysisAliasing &D);
365 void OptimizationFailureHandler(
366 const llvm::DiagnosticInfoOptimizationFailure &D);
367 };
368
369 void BackendConsumer::anchor() {}
370}
371
372bool ClangDiagnosticHandler::handleDiagnostics(const DiagnosticInfo &DI) {
373 BackendCon->DiagnosticHandlerImpl(DI);
1
Calling 'BackendConsumer::DiagnosticHandlerImpl'
374 return true;
375}
376
377/// ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr
378/// buffer to be a valid FullSourceLoc.
379static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D,
380 SourceManager &CSM) {
381 // Get both the clang and llvm source managers. The location is relative to
382 // a memory buffer that the LLVM Source Manager is handling, we need to add
383 // a copy to the Clang source manager.
384 const llvm::SourceMgr &LSM = *D.getSourceMgr();
385
386 // We need to copy the underlying LLVM memory buffer because llvm::SourceMgr
387 // already owns its one and clang::SourceManager wants to own its one.
388 const MemoryBuffer *LBuf =
389 LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));
390
391 // Create the copy and transfer ownership to clang::SourceManager.
392 // TODO: Avoid copying files into memory.
393 std::unique_ptr<llvm::MemoryBuffer> CBuf =
394 llvm::MemoryBuffer::getMemBufferCopy(LBuf->getBuffer(),
395 LBuf->getBufferIdentifier());
396 // FIXME: Keep a file ID map instead of creating new IDs for each location.
397 FileID FID = CSM.createFileID(std::move(CBuf));
398
399 // Translate the offset into the file.
400 unsigned Offset = D.getLoc().getPointer() - LBuf->getBufferStart();
401 SourceLocation NewLoc =
402 CSM.getLocForStartOfFile(FID).getLocWithOffset(Offset);
403 return FullSourceLoc(NewLoc, CSM);
404}
405
406
407/// InlineAsmDiagHandler2 - This function is invoked when the backend hits an
408/// error parsing inline asm. The SMDiagnostic indicates the error relative to
409/// the temporary memory buffer that the inline asm parser has set up.
410void BackendConsumer::InlineAsmDiagHandler2(const llvm::SMDiagnostic &D,
411 SourceLocation LocCookie) {
412 // There are a couple of different kinds of errors we could get here. First,
413 // we re-format the SMDiagnostic in terms of a clang diagnostic.
414
415 // Strip "error: " off the start of the message string.
416 StringRef Message = D.getMessage();
417 if (Message.startswith("error: "))
418 Message = Message.substr(7);
419
420 // If the SMDiagnostic has an inline asm source location, translate it.
421 FullSourceLoc Loc;
422 if (D.getLoc() != SMLoc())
423 Loc = ConvertBackendLocation(D, Context->getSourceManager());
424
425 unsigned DiagID;
426 switch (D.getKind()) {
427 case llvm::SourceMgr::DK_Error:
428 DiagID = diag::err_fe_inline_asm;
429 break;
430 case llvm::SourceMgr::DK_Warning:
431 DiagID = diag::warn_fe_inline_asm;
432 break;
433 case llvm::SourceMgr::DK_Note:
434 DiagID = diag::note_fe_inline_asm;
435 break;
436 case llvm::SourceMgr::DK_Remark:
437 llvm_unreachable("remarks unexpected")::llvm::llvm_unreachable_internal("remarks unexpected", "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 437)
;
438 }
439 // If this problem has clang-level source location information, report the
440 // issue in the source with a note showing the instantiated
441 // code.
442 if (LocCookie.isValid()) {
443 Diags.Report(LocCookie, DiagID).AddString(Message);
444
445 if (D.getLoc().isValid()) {
446 DiagnosticBuilder B = Diags.Report(Loc, diag::note_fe_inline_asm_here);
447 // Convert the SMDiagnostic ranges into SourceRange and attach them
448 // to the diagnostic.
449 for (const std::pair<unsigned, unsigned> &Range : D.getRanges()) {
450 unsigned Column = D.getColumnNo();
451 B << SourceRange(Loc.getLocWithOffset(Range.first - Column),
452 Loc.getLocWithOffset(Range.second - Column));
453 }
454 }
455 return;
456 }
457
458 // Otherwise, report the backend issue as occurring in the generated .s file.
459 // If Loc is invalid, we still need to report the issue, it just gets no
460 // location info.
461 Diags.Report(Loc, DiagID).AddString(Message);
462}
463
464#define ComputeDiagID(Severity, GroupName, DiagID) \
465 do { \
466 switch (Severity) { \
467 case llvm::DS_Error: \
468 DiagID = diag::err_fe_##GroupName; \
469 break; \
470 case llvm::DS_Warning: \
471 DiagID = diag::warn_fe_##GroupName; \
472 break; \
473 case llvm::DS_Remark: \
474 llvm_unreachable("'remark' severity not expected")::llvm::llvm_unreachable_internal("'remark' severity not expected"
, "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 474)
; \
475 break; \
476 case llvm::DS_Note: \
477 DiagID = diag::note_fe_##GroupName; \
478 break; \
479 } \
480 } while (false)
481
482#define ComputeDiagRemarkID(Severity, GroupName, DiagID)do { switch (Severity) { case llvm::DS_Error: DiagID = diag::
err_fe_GroupName; break; case llvm::DS_Warning: DiagID = diag
::warn_fe_GroupName; break; case llvm::DS_Remark: DiagID = diag
::remark_fe_GroupName; break; case llvm::DS_Note: DiagID = diag
::note_fe_GroupName; break; } } while (false)
\
483 do { \
484 switch (Severity) { \
485 case llvm::DS_Error: \
486 DiagID = diag::err_fe_##GroupName; \
487 break; \
488 case llvm::DS_Warning: \
489 DiagID = diag::warn_fe_##GroupName; \
490 break; \
491 case llvm::DS_Remark: \
492 DiagID = diag::remark_fe_##GroupName; \
493 break; \
494 case llvm::DS_Note: \
495 DiagID = diag::note_fe_##GroupName; \
496 break; \
497 } \
498 } while (false)
499
500bool
501BackendConsumer::InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D) {
502 unsigned DiagID;
503 ComputeDiagID(D.getSeverity(), inline_asm, DiagID);
504 std::string Message = D.getMsgStr().str();
505
506 // If this problem has clang-level source location information, report the
507 // issue as being a problem in the source with a note showing the instantiated
508 // code.
509 SourceLocation LocCookie =
510 SourceLocation::getFromRawEncoding(D.getLocCookie());
511 if (LocCookie.isValid())
512 Diags.Report(LocCookie, DiagID).AddString(Message);
513 else {
514 // Otherwise, report the backend diagnostic as occurring in the generated
515 // .s file.
516 // If Loc is invalid, we still need to report the diagnostic, it just gets
517 // no location info.
518 FullSourceLoc Loc;
519 Diags.Report(Loc, DiagID).AddString(Message);
520 }
521 // We handled all the possible severities.
522 return true;
523}
524
525bool
526BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) {
527 if (D.getSeverity() != llvm::DS_Warning)
528 // For now, the only support we have for StackSize diagnostic is warning.
529 // We do not know how to format other severities.
530 return false;
531
532 if (const Decl *ND = Gen->GetDeclForMangledName(D.getFunction().getName())) {
533 // FIXME: Shouldn't need to truncate to uint32_t
534 Diags.Report(ND->getASTContext().getFullLoc(ND->getLocation()),
535 diag::warn_fe_frame_larger_than)
536 << static_cast<uint32_t>(D.getStackSize()) << Decl::castToDeclContext(ND);
537 return true;
538 }
539
540 return false;
541}
542
543const FullSourceLoc BackendConsumer::getBestLocationFromDebugLoc(
544 const llvm::DiagnosticInfoWithLocationBase &D, bool &BadDebugInfo,
545 StringRef &Filename, unsigned &Line, unsigned &Column) const {
546 SourceManager &SourceMgr = Context->getSourceManager();
547 FileManager &FileMgr = SourceMgr.getFileManager();
548 SourceLocation DILoc;
549
550 if (D.isLocationAvailable()) {
7
Taking false branch
551 D.getLocation(&Filename, &Line, &Column);
552 const FileEntry *FE = FileMgr.getFile(Filename);
553 if (FE && Line > 0) {
554 // If -gcolumn-info was not used, Column will be 0. This upsets the
555 // source manager, so pass 1 if Column is not set.
556 DILoc = SourceMgr.translateFileLineCol(FE, Line, Column ? Column : 1);
557 }
558 BadDebugInfo = DILoc.isInvalid();
559 }
560
561 // If a location isn't available, try to approximate it using the associated
562 // function definition. We use the definition's right brace to differentiate
563 // from diagnostics that genuinely relate to the function itself.
564 FullSourceLoc Loc(DILoc, SourceMgr);
565 if (Loc.isInvalid())
8
Taking true branch
566 if (const Decl *FD = Gen->GetDeclForMangledName(D.getFunction().getName()))
9
Assuming 'FD' is null
10
Taking false branch
567 Loc = FD->getASTContext().getFullLoc(FD->getLocation());
568
569 if (DILoc.isInvalid() && D.isLocationAvailable())
11
Taking true branch
570 // If we were not able to translate the file:line:col information
571 // back to a SourceLocation, at least emit a note stating that
572 // we could not translate this location. This can happen in the
573 // case of #line directives.
574 Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
12
2nd function call argument is an uninitialized value
575 << Filename << Line << Column;
576
577 return Loc;
578}
579
580void BackendConsumer::UnsupportedDiagHandler(
581 const llvm::DiagnosticInfoUnsupported &D) {
582 // We only support errors.
583 assert(D.getSeverity() == llvm::DS_Error)(static_cast <bool> (D.getSeverity() == llvm::DS_Error)
? void (0) : __assert_fail ("D.getSeverity() == llvm::DS_Error"
, "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 583, __extension__ __PRETTY_FUNCTION__))
;
584
585 StringRef Filename;
586 unsigned Line, Column;
4
'Line' declared without an initial value
587 bool BadDebugInfo = false;
588 FullSourceLoc Loc =
589 getBestLocationFromDebugLoc(D, BadDebugInfo, Filename, Line, Column);
5
Passing value via 4th parameter 'Line'
6
Calling 'BackendConsumer::getBestLocationFromDebugLoc'
590
591 Diags.Report(Loc, diag::err_fe_backend_unsupported) << D.getMessage().str();
592
593 if (BadDebugInfo)
594 // If we were not able to translate the file:line:col information
595 // back to a SourceLocation, at least emit a note stating that
596 // we could not translate this location. This can happen in the
597 // case of #line directives.
598 Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
599 << Filename << Line << Column;
600}
601
602void BackendConsumer::EmitOptimizationMessage(
603 const llvm::DiagnosticInfoOptimizationBase &D, unsigned DiagID) {
604 // We only support warnings and remarks.
605 assert(D.getSeverity() == llvm::DS_Remark ||(static_cast <bool> (D.getSeverity() == llvm::DS_Remark
|| D.getSeverity() == llvm::DS_Warning) ? void (0) : __assert_fail
("D.getSeverity() == llvm::DS_Remark || D.getSeverity() == llvm::DS_Warning"
, "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 606, __extension__ __PRETTY_FUNCTION__))
606 D.getSeverity() == llvm::DS_Warning)(static_cast <bool> (D.getSeverity() == llvm::DS_Remark
|| D.getSeverity() == llvm::DS_Warning) ? void (0) : __assert_fail
("D.getSeverity() == llvm::DS_Remark || D.getSeverity() == llvm::DS_Warning"
, "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 606, __extension__ __PRETTY_FUNCTION__))
;
607
608 StringRef Filename;
609 unsigned Line, Column;
610 bool BadDebugInfo = false;
611 FullSourceLoc Loc =
612 getBestLocationFromDebugLoc(D, BadDebugInfo, Filename, Line, Column);
613
614 std::string Msg;
615 raw_string_ostream MsgStream(Msg);
616 MsgStream << D.getMsg();
617
618 if (D.getHotness())
619 MsgStream << " (hotness: " << *D.getHotness() << ")";
620
621 Diags.Report(Loc, DiagID)
622 << AddFlagValue(D.getPassName())
623 << MsgStream.str();
624
625 if (BadDebugInfo)
626 // If we were not able to translate the file:line:col information
627 // back to a SourceLocation, at least emit a note stating that
628 // we could not translate this location. This can happen in the
629 // case of #line directives.
630 Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
631 << Filename << Line << Column;
632}
633
634void BackendConsumer::OptimizationRemarkHandler(
635 const llvm::DiagnosticInfoOptimizationBase &D) {
636 // Without hotness information, don't show noisy remarks.
637 if (D.isVerbose() && !D.getHotness())
638 return;
639
640 if (D.isPassed()) {
641 // Optimization remarks are active only if the -Rpass flag has a regular
642 // expression that matches the name of the pass name in \p D.
643 if (CodeGenOpts.OptimizationRemarkPattern &&
644 CodeGenOpts.OptimizationRemarkPattern->match(D.getPassName()))
645 EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark);
646 } else if (D.isMissed()) {
647 // Missed optimization remarks are active only if the -Rpass-missed
648 // flag has a regular expression that matches the name of the pass
649 // name in \p D.
650 if (CodeGenOpts.OptimizationRemarkMissedPattern &&
651 CodeGenOpts.OptimizationRemarkMissedPattern->match(D.getPassName()))
652 EmitOptimizationMessage(
653 D, diag::remark_fe_backend_optimization_remark_missed);
654 } else {
655 assert(D.isAnalysis() && "Unknown remark type")(static_cast <bool> (D.isAnalysis() && "Unknown remark type"
) ? void (0) : __assert_fail ("D.isAnalysis() && \"Unknown remark type\""
, "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 655, __extension__ __PRETTY_FUNCTION__))
;
656
657 bool ShouldAlwaysPrint = false;
658 if (auto *ORA = dyn_cast<llvm::OptimizationRemarkAnalysis>(&D))
659 ShouldAlwaysPrint = ORA->shouldAlwaysPrint();
660
661 if (ShouldAlwaysPrint ||
662 (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
663 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
664 EmitOptimizationMessage(
665 D, diag::remark_fe_backend_optimization_remark_analysis);
666 }
667}
668
669void BackendConsumer::OptimizationRemarkHandler(
670 const llvm::OptimizationRemarkAnalysisFPCommute &D) {
671 // Optimization analysis remarks are active if the pass name is set to
672 // llvm::DiagnosticInfo::AlwasyPrint or if the -Rpass-analysis flag has a
673 // regular expression that matches the name of the pass name in \p D.
674
675 if (D.shouldAlwaysPrint() ||
676 (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
677 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
678 EmitOptimizationMessage(
679 D, diag::remark_fe_backend_optimization_remark_analysis_fpcommute);
680}
681
682void BackendConsumer::OptimizationRemarkHandler(
683 const llvm::OptimizationRemarkAnalysisAliasing &D) {
684 // Optimization analysis remarks are active if the pass name is set to
685 // llvm::DiagnosticInfo::AlwasyPrint or if the -Rpass-analysis flag has a
686 // regular expression that matches the name of the pass name in \p D.
687
688 if (D.shouldAlwaysPrint() ||
689 (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
690 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
691 EmitOptimizationMessage(
692 D, diag::remark_fe_backend_optimization_remark_analysis_aliasing);
693}
694
695void BackendConsumer::OptimizationFailureHandler(
696 const llvm::DiagnosticInfoOptimizationFailure &D) {
697 EmitOptimizationMessage(D, diag::warn_fe_backend_optimization_failure);
698}
699
700/// This function is invoked when the backend needs
701/// to report something to the user.
702void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) {
703 unsigned DiagID = diag::err_fe_inline_asm;
704 llvm::DiagnosticSeverity Severity = DI.getSeverity();
705 // Get the diagnostic ID based.
706 switch (DI.getKind()) {
2
Control jumps to 'case DK_Unsupported:' at line 769
707 case llvm::DK_InlineAsm:
708 if (InlineAsmDiagHandler(cast<DiagnosticInfoInlineAsm>(DI)))
709 return;
710 ComputeDiagID(Severity, inline_asm, DiagID);
711 break;
712 case llvm::DK_StackSize:
713 if (StackSizeDiagHandler(cast<DiagnosticInfoStackSize>(DI)))
714 return;
715 ComputeDiagID(Severity, backend_frame_larger_than, DiagID);
716 break;
717 case DK_Linker:
718 assert(CurLinkModule)(static_cast <bool> (CurLinkModule) ? void (0) : __assert_fail
("CurLinkModule", "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 718, __extension__ __PRETTY_FUNCTION__))
;
719 // FIXME: stop eating the warnings and notes.
720 if (Severity != DS_Error)
721 return;
722 DiagID = diag::err_fe_cannot_link_module;
723 break;
724 case llvm::DK_OptimizationRemark:
725 // Optimization remarks are always handled completely by this
726 // handler. There is no generic way of emitting them.
727 OptimizationRemarkHandler(cast<OptimizationRemark>(DI));
728 return;
729 case llvm::DK_OptimizationRemarkMissed:
730 // Optimization remarks are always handled completely by this
731 // handler. There is no generic way of emitting them.
732 OptimizationRemarkHandler(cast<OptimizationRemarkMissed>(DI));
733 return;
734 case llvm::DK_OptimizationRemarkAnalysis:
735 // Optimization remarks are always handled completely by this
736 // handler. There is no generic way of emitting them.
737 OptimizationRemarkHandler(cast<OptimizationRemarkAnalysis>(DI));
738 return;
739 case llvm::DK_OptimizationRemarkAnalysisFPCommute:
740 // Optimization remarks are always handled completely by this
741 // handler. There is no generic way of emitting them.
742 OptimizationRemarkHandler(cast<OptimizationRemarkAnalysisFPCommute>(DI));
743 return;
744 case llvm::DK_OptimizationRemarkAnalysisAliasing:
745 // Optimization remarks are always handled completely by this
746 // handler. There is no generic way of emitting them.
747 OptimizationRemarkHandler(cast<OptimizationRemarkAnalysisAliasing>(DI));
748 return;
749 case llvm::DK_MachineOptimizationRemark:
750 // Optimization remarks are always handled completely by this
751 // handler. There is no generic way of emitting them.
752 OptimizationRemarkHandler(cast<MachineOptimizationRemark>(DI));
753 return;
754 case llvm::DK_MachineOptimizationRemarkMissed:
755 // Optimization remarks are always handled completely by this
756 // handler. There is no generic way of emitting them.
757 OptimizationRemarkHandler(cast<MachineOptimizationRemarkMissed>(DI));
758 return;
759 case llvm::DK_MachineOptimizationRemarkAnalysis:
760 // Optimization remarks are always handled completely by this
761 // handler. There is no generic way of emitting them.
762 OptimizationRemarkHandler(cast<MachineOptimizationRemarkAnalysis>(DI));
763 return;
764 case llvm::DK_OptimizationFailure:
765 // Optimization failures are always handled completely by this
766 // handler.
767 OptimizationFailureHandler(cast<DiagnosticInfoOptimizationFailure>(DI));
768 return;
769 case llvm::DK_Unsupported:
770 UnsupportedDiagHandler(cast<DiagnosticInfoUnsupported>(DI));
3
Calling 'BackendConsumer::UnsupportedDiagHandler'
771 return;
772 default:
773 // Plugin IDs are not bound to any value as they are set dynamically.
774 ComputeDiagRemarkID(Severity, backend_plugin, DiagID)do { switch (Severity) { case llvm::DS_Error: DiagID = diag::
err_fe_backend_plugin; break; case llvm::DS_Warning: DiagID =
diag::warn_fe_backend_plugin; break; case llvm::DS_Remark: DiagID
= diag::remark_fe_backend_plugin; break; case llvm::DS_Note:
DiagID = diag::note_fe_backend_plugin; break; } } while (false
)
;
775 break;
776 }
777 std::string MsgStorage;
778 {
779 raw_string_ostream Stream(MsgStorage);
780 DiagnosticPrinterRawOStream DP(Stream);
781 DI.print(DP);
782 }
783
784 if (DiagID == diag::err_fe_cannot_link_module) {
785 Diags.Report(diag::err_fe_cannot_link_module)
786 << CurLinkModule->getModuleIdentifier() << MsgStorage;
787 return;
788 }
789
790 // Report the backend message using the usual diagnostic mechanism.
791 FullSourceLoc Loc;
792 Diags.Report(Loc, DiagID).AddString(MsgStorage);
793}
794#undef ComputeDiagID
795
796CodeGenAction::CodeGenAction(unsigned _Act, LLVMContext *_VMContext)
797 : Act(_Act), VMContext(_VMContext ? _VMContext : new LLVMContext),
798 OwnsVMContext(!_VMContext) {}
799
800CodeGenAction::~CodeGenAction() {
801 TheModule.reset();
802 if (OwnsVMContext)
803 delete VMContext;
804}
805
806bool CodeGenAction::hasIRSupport() const { return true; }
807
808void CodeGenAction::EndSourceFileAction() {
809 // If the consumer creation failed, do nothing.
810 if (!getCompilerInstance().hasASTConsumer())
811 return;
812
813 // Steal the module from the consumer.
814 TheModule = BEConsumer->takeModule();
815}
816
817std::unique_ptr<llvm::Module> CodeGenAction::takeModule() {
818 return std::move(TheModule);
819}
820
821llvm::LLVMContext *CodeGenAction::takeLLVMContext() {
822 OwnsVMContext = false;
823 return VMContext;
824}
825
826static std::unique_ptr<raw_pwrite_stream>
827GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) {
828 switch (Action) {
829 case Backend_EmitAssembly:
830 return CI.createDefaultOutputFile(false, InFile, "s");
831 case Backend_EmitLL:
832 return CI.createDefaultOutputFile(false, InFile, "ll");
833 case Backend_EmitBC:
834 return CI.createDefaultOutputFile(true, InFile, "bc");
835 case Backend_EmitNothing:
836 return nullptr;
837 case Backend_EmitMCNull:
838 return CI.createNullOutputFile();
839 case Backend_EmitObj:
840 return CI.createDefaultOutputFile(true, InFile, "o");
841 }
842
843 llvm_unreachable("Invalid action!")::llvm::llvm_unreachable_internal("Invalid action!", "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 843)
;
844}
845
846std::unique_ptr<ASTConsumer>
847CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
848 BackendAction BA = static_cast<BackendAction>(Act);
849 std::unique_ptr<raw_pwrite_stream> OS = CI.takeOutputStream();
850 if (!OS)
851 OS = GetOutputStream(CI, InFile, BA);
852
853 if (BA != Backend_EmitNothing && !OS)
854 return nullptr;
855
856 // Load bitcode modules to link with, if we need to.
857 if (LinkModules.empty())
858 for (const CodeGenOptions::BitcodeFileToLink &F :
859 CI.getCodeGenOpts().LinkBitcodeFiles) {
860 auto BCBuf = CI.getFileManager().getBufferForFile(F.Filename);
861 if (!BCBuf) {
862 CI.getDiagnostics().Report(diag::err_cannot_open_file)
863 << F.Filename << BCBuf.getError().message();
864 LinkModules.clear();
865 return nullptr;
866 }
867
868 Expected<std::unique_ptr<llvm::Module>> ModuleOrErr =
869 getOwningLazyBitcodeModule(std::move(*BCBuf), *VMContext);
870 if (!ModuleOrErr) {
871 handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
872 CI.getDiagnostics().Report(diag::err_cannot_open_file)
873 << F.Filename << EIB.message();
874 });
875 LinkModules.clear();
876 return nullptr;
877 }
878 LinkModules.push_back({std::move(ModuleOrErr.get()), F.PropagateAttrs,
879 F.Internalize, F.LinkFlags});
880 }
881
882 CoverageSourceInfo *CoverageInfo = nullptr;
883 // Add the preprocessor callback only when the coverage mapping is generated.
884 if (CI.getCodeGenOpts().CoverageMapping) {
885 CoverageInfo = new CoverageSourceInfo;
886 CI.getPreprocessor().addPPCallbacks(
887 std::unique_ptr<PPCallbacks>(CoverageInfo));
888 }
889
890 std::unique_ptr<BackendConsumer> Result(new BackendConsumer(
891 BA, CI.getDiagnostics(), CI.getHeaderSearchOpts(),
892 CI.getPreprocessorOpts(), CI.getCodeGenOpts(), CI.getTargetOpts(),
893 CI.getLangOpts(), CI.getFrontendOpts().ShowTimers, InFile,
894 std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
895 BEConsumer = Result.get();
896
897 // Enable generating macro debug info only when debug info is not disabled and
898 // also macro debug info is enabled.
899 if (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo &&
900 CI.getCodeGenOpts().MacroDebugInfo) {
901 std::unique_ptr<PPCallbacks> Callbacks =
902 llvm::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),
903 CI.getPreprocessor());
904 CI.getPreprocessor().addPPCallbacks(std::move(Callbacks));
905 }
906
907 return std::move(Result);
908}
909
910static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
911 void *Context,
912 unsigned LocCookie) {
913 SM.print(nullptr, llvm::errs());
914
915 auto Diags = static_cast<DiagnosticsEngine *>(Context);
916 unsigned DiagID;
917 switch (SM.getKind()) {
918 case llvm::SourceMgr::DK_Error:
919 DiagID = diag::err_fe_inline_asm;
920 break;
921 case llvm::SourceMgr::DK_Warning:
922 DiagID = diag::warn_fe_inline_asm;
923 break;
924 case llvm::SourceMgr::DK_Note:
925 DiagID = diag::note_fe_inline_asm;
926 break;
927 case llvm::SourceMgr::DK_Remark:
928 llvm_unreachable("remarks unexpected")::llvm::llvm_unreachable_internal("remarks unexpected", "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 928)
;
929 }
930
931 Diags->Report(DiagID).AddString("cannot compile inline asm");
932}
933
934std::unique_ptr<llvm::Module> CodeGenAction::loadModule(MemoryBufferRef MBRef) {
935 CompilerInstance &CI = getCompilerInstance();
936 SourceManager &SM = CI.getSourceManager();
937
938 // For ThinLTO backend invocations, ensure that the context
939 // merges types based on ODR identifiers. We also need to read
940 // the correct module out of a multi-module bitcode file.
941 if (!CI.getCodeGenOpts().ThinLTOIndexFile.empty()) {
942 VMContext->enableDebugTypeODRUniquing();
943
944 auto DiagErrors = [&](Error E) -> std::unique_ptr<llvm::Module> {
945 unsigned DiagID =
946 CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
947 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
948 CI.getDiagnostics().Report(DiagID) << EIB.message();
949 });
950 return {};
951 };
952
953 Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef);
954 if (!BMsOrErr)
955 return DiagErrors(BMsOrErr.takeError());
956 BitcodeModule *Bm = FindThinLTOModule(*BMsOrErr);
957 // We have nothing to do if the file contains no ThinLTO module. This is
958 // possible if ThinLTO compilation was not able to split module. Content of
959 // the file was already processed by indexing and will be passed to the
960 // linker using merged object file.
961 if (!Bm) {
962 auto M = llvm::make_unique<llvm::Module>("empty", *VMContext);
963 M->setTargetTriple(CI.getTargetOpts().Triple);
964 return M;
965 }
966 Expected<std::unique_ptr<llvm::Module>> MOrErr =
967 Bm->parseModule(*VMContext);
968 if (!MOrErr)
969 return DiagErrors(MOrErr.takeError());
970 return std::move(*MOrErr);
971 }
972
973 llvm::SMDiagnostic Err;
974 if (std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext))
975 return M;
976
977 // Translate from the diagnostic info to the SourceManager location if
978 // available.
979 // TODO: Unify this with ConvertBackendLocation()
980 SourceLocation Loc;
981 if (Err.getLineNo() > 0) {
982 assert(Err.getColumnNo() >= 0)(static_cast <bool> (Err.getColumnNo() >= 0) ? void (
0) : __assert_fail ("Err.getColumnNo() >= 0", "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 982, __extension__ __PRETTY_FUNCTION__))
;
983 Loc = SM.translateFileLineCol(SM.getFileEntryForID(SM.getMainFileID()),
984 Err.getLineNo(), Err.getColumnNo() + 1);
985 }
986
987 // Strip off a leading diagnostic code if there is one.
988 StringRef Msg = Err.getMessage();
989 if (Msg.startswith("error: "))
990 Msg = Msg.substr(7);
991
992 unsigned DiagID =
993 CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
994
995 CI.getDiagnostics().Report(Loc, DiagID) << Msg;
996 return {};
997}
998
999void CodeGenAction::ExecuteAction() {
1000 // If this is an IR file, we have to treat it specially.
1001 if (getCurrentFileKind().getLanguage() == InputKind::LLVM_IR) {
1002 BackendAction BA = static_cast<BackendAction>(Act);
1003 CompilerInstance &CI = getCompilerInstance();
1004 std::unique_ptr<raw_pwrite_stream> OS =
1005 GetOutputStream(CI, getCurrentFile(), BA);
1006 if (BA != Backend_EmitNothing && !OS)
1007 return;
1008
1009 bool Invalid;
1010 SourceManager &SM = CI.getSourceManager();
1011 FileID FID = SM.getMainFileID();
1012 llvm::MemoryBuffer *MainFile = SM.getBuffer(FID, &Invalid);
1013 if (Invalid)
1014 return;
1015
1016 TheModule = loadModule(*MainFile);
1017 if (!TheModule)
1018 return;
1019
1020 const TargetOptions &TargetOpts = CI.getTargetOpts();
1021 if (TheModule->getTargetTriple() != TargetOpts.Triple) {
1022 CI.getDiagnostics().Report(SourceLocation(),
1023 diag::warn_fe_override_module)
1024 << TargetOpts.Triple;
1025 TheModule->setTargetTriple(TargetOpts.Triple);
1026 }
1027
1028 EmbedBitcode(TheModule.get(), CI.getCodeGenOpts(),
1029 MainFile->getMemBufferRef());
1030
1031 LLVMContext &Ctx = TheModule->getContext();
1032 Ctx.setInlineAsmDiagnosticHandler(BitcodeInlineAsmDiagHandler,
1033 &CI.getDiagnostics());
1034
1035 EmitBackendOutput(CI.getDiagnostics(), CI.getHeaderSearchOpts(),
1036 CI.getCodeGenOpts(), TargetOpts, CI.getLangOpts(),
1037 CI.getTarget().getDataLayout(), TheModule.get(), BA,
1038 std::move(OS));
1039 return;
1040 }
1041
1042 // Otherwise follow the normal AST path.
1043 this->ASTFrontendAction::ExecuteAction();
1044}
1045
1046//
1047
1048void EmitAssemblyAction::anchor() { }
1049EmitAssemblyAction::EmitAssemblyAction(llvm::LLVMContext *_VMContext)
1050 : CodeGenAction(Backend_EmitAssembly, _VMContext) {}
1051
1052void EmitBCAction::anchor() { }
1053EmitBCAction::EmitBCAction(llvm::LLVMContext *_VMContext)
1054 : CodeGenAction(Backend_EmitBC, _VMContext) {}
1055
1056void EmitLLVMAction::anchor() { }
1057EmitLLVMAction::EmitLLVMAction(llvm::LLVMContext *_VMContext)
1058 : CodeGenAction(Backend_EmitLL, _VMContext) {}
1059
1060void EmitLLVMOnlyAction::anchor() { }
1061EmitLLVMOnlyAction::EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext)
1062 : CodeGenAction(Backend_EmitNothing, _VMContext) {}
1063
1064void EmitCodeGenOnlyAction::anchor() { }
1065EmitCodeGenOnlyAction::EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext)
1066 : CodeGenAction(Backend_EmitMCNull, _VMContext) {}
1067
1068void EmitObjAction::anchor() { }
1069EmitObjAction::EmitObjAction(llvm::LLVMContext *_VMContext)
1070 : CodeGenAction(Backend_EmitObj, _VMContext) {}