Bug Summary

File:tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp
Warning:line 748, column 15
Potential leak of memory pointed to by field 'Obj'

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 SerializedDiagnosticPrinter.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~svn338205/build-llvm/tools/clang/lib/Frontend -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/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/8/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-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/Frontend -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-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp -faddrsig
1//===--- SerializedDiagnosticPrinter.cpp - Serializer for diagnostics -----===//
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/Frontend/SerializedDiagnosticPrinter.h"
11#include "clang/Basic/Diagnostic.h"
12#include "clang/Basic/DiagnosticOptions.h"
13#include "clang/Basic/SourceManager.h"
14#include "clang/Frontend/DiagnosticRenderer.h"
15#include "clang/Frontend/FrontendDiagnostic.h"
16#include "clang/Frontend/SerializedDiagnosticReader.h"
17#include "clang/Frontend/SerializedDiagnostics.h"
18#include "clang/Frontend/TextDiagnosticPrinter.h"
19#include "clang/Lex/Lexer.h"
20#include "llvm/ADT/DenseSet.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/SmallString.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/Support/raw_ostream.h"
25#include <utility>
26
27using namespace clang;
28using namespace clang::serialized_diags;
29
30namespace {
31
32class AbbreviationMap {
33 llvm::DenseMap<unsigned, unsigned> Abbrevs;
34public:
35 AbbreviationMap() {}
36
37 void set(unsigned recordID, unsigned abbrevID) {
38 assert(Abbrevs.find(recordID) == Abbrevs.end()(static_cast <bool> (Abbrevs.find(recordID) == Abbrevs.
end() && "Abbreviation already set.") ? void (0) : __assert_fail
("Abbrevs.find(recordID) == Abbrevs.end() && \"Abbreviation already set.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp"
, 39, __extension__ __PRETTY_FUNCTION__))
39 && "Abbreviation already set.")(static_cast <bool> (Abbrevs.find(recordID) == Abbrevs.
end() && "Abbreviation already set.") ? void (0) : __assert_fail
("Abbrevs.find(recordID) == Abbrevs.end() && \"Abbreviation already set.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp"
, 39, __extension__ __PRETTY_FUNCTION__));
40 Abbrevs[recordID] = abbrevID;
41 }
42
43 unsigned get(unsigned recordID) {
44 assert(Abbrevs.find(recordID) != Abbrevs.end() &&(static_cast <bool> (Abbrevs.find(recordID) != Abbrevs.
end() && "Abbreviation not set.") ? void (0) : __assert_fail
("Abbrevs.find(recordID) != Abbrevs.end() && \"Abbreviation not set.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp"
, 45, __extension__ __PRETTY_FUNCTION__))
45 "Abbreviation not set.")(static_cast <bool> (Abbrevs.find(recordID) != Abbrevs.
end() && "Abbreviation not set.") ? void (0) : __assert_fail
("Abbrevs.find(recordID) != Abbrevs.end() && \"Abbreviation not set.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp"
, 45, __extension__ __PRETTY_FUNCTION__));
46 return Abbrevs[recordID];
47 }
48};
49
50typedef SmallVector<uint64_t, 64> RecordData;
51typedef SmallVectorImpl<uint64_t> RecordDataImpl;
52typedef ArrayRef<uint64_t> RecordDataRef;
53
54class SDiagsWriter;
55
56class SDiagsRenderer : public DiagnosticNoteRenderer {
57 SDiagsWriter &Writer;
58public:
59 SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts,
60 DiagnosticOptions *DiagOpts)
61 : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {}
62
63 ~SDiagsRenderer() override {}
64
65protected:
66 void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
67 DiagnosticsEngine::Level Level, StringRef Message,
68 ArrayRef<CharSourceRange> Ranges,
69 DiagOrStoredDiag D) override;
70
71 void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
72 DiagnosticsEngine::Level Level,
73 ArrayRef<CharSourceRange> Ranges) override {}
74
75 void emitNote(FullSourceLoc Loc, StringRef Message) override;
76
77 void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
78 SmallVectorImpl<CharSourceRange> &Ranges,
79 ArrayRef<FixItHint> Hints) override;
80
81 void beginDiagnostic(DiagOrStoredDiag D,
82 DiagnosticsEngine::Level Level) override;
83 void endDiagnostic(DiagOrStoredDiag D,
84 DiagnosticsEngine::Level Level) override;
85};
86
87typedef llvm::DenseMap<unsigned, unsigned> AbbrevLookup;
88
89class SDiagsMerger : SerializedDiagnosticReader {
90 SDiagsWriter &Writer;
91 AbbrevLookup FileLookup;
92 AbbrevLookup CategoryLookup;
93 AbbrevLookup DiagFlagLookup;
94
95public:
96 SDiagsMerger(SDiagsWriter &Writer)
97 : SerializedDiagnosticReader(), Writer(Writer) {}
98
99 std::error_code mergeRecordsFromFile(const char *File) {
100 return readDiagnostics(File);
101 }
102
103protected:
104 std::error_code visitStartOfDiagnostic() override;
105 std::error_code visitEndOfDiagnostic() override;
106 std::error_code visitCategoryRecord(unsigned ID, StringRef Name) override;
107 std::error_code visitDiagFlagRecord(unsigned ID, StringRef Name) override;
108 std::error_code visitDiagnosticRecord(
109 unsigned Severity, const serialized_diags::Location &Location,
110 unsigned Category, unsigned Flag, StringRef Message) override;
111 std::error_code visitFilenameRecord(unsigned ID, unsigned Size,
112 unsigned Timestamp,
113 StringRef Name) override;
114 std::error_code visitFixitRecord(const serialized_diags::Location &Start,
115 const serialized_diags::Location &End,
116 StringRef CodeToInsert) override;
117 std::error_code
118 visitSourceRangeRecord(const serialized_diags::Location &Start,
119 const serialized_diags::Location &End) override;
120
121private:
122 std::error_code adjustSourceLocFilename(RecordData &Record,
123 unsigned int offset);
124
125 void adjustAbbrevID(RecordData &Record, AbbrevLookup &Lookup,
126 unsigned NewAbbrev);
127
128 void writeRecordWithAbbrev(unsigned ID, RecordData &Record);
129
130 void writeRecordWithBlob(unsigned ID, RecordData &Record, StringRef Blob);
131};
132
133class SDiagsWriter : public DiagnosticConsumer {
134 friend class SDiagsRenderer;
135 friend class SDiagsMerger;
136
137 struct SharedState;
138
139 explicit SDiagsWriter(std::shared_ptr<SharedState> State)
140 : LangOpts(nullptr), OriginalInstance(false), MergeChildRecords(false),
141 State(std::move(State)) {}
142
143public:
144 SDiagsWriter(StringRef File, DiagnosticOptions *Diags, bool MergeChildRecords)
145 : LangOpts(nullptr), OriginalInstance(true),
146 MergeChildRecords(MergeChildRecords),
147 State(std::make_shared<SharedState>(File, Diags)) {
148 if (MergeChildRecords)
149 RemoveOldDiagnostics();
150 EmitPreamble();
151 }
152
153 ~SDiagsWriter() override {}
154
155 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
156 const Diagnostic &Info) override;
157
158 void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override {
159 LangOpts = &LO;
160 }
161
162 void finish() override;
163
164private:
165 /// Build a DiagnosticsEngine to emit diagnostics about the diagnostics
166 DiagnosticsEngine *getMetaDiags();
167
168 /// Remove old copies of the serialized diagnostics. This is necessary
169 /// so that we can detect when subprocesses write diagnostics that we should
170 /// merge into our own.
171 void RemoveOldDiagnostics();
172
173 /// Emit the preamble for the serialized diagnostics.
174 void EmitPreamble();
175
176 /// Emit the BLOCKINFO block.
177 void EmitBlockInfoBlock();
178
179 /// Emit the META data block.
180 void EmitMetaBlock();
181
182 /// Start a DIAG block.
183 void EnterDiagBlock();
184
185 /// End a DIAG block.
186 void ExitDiagBlock();
187
188 /// Emit a DIAG record.
189 void EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
190 DiagnosticsEngine::Level Level, StringRef Message,
191 DiagOrStoredDiag D);
192
193 /// Emit FIXIT and SOURCE_RANGE records for a diagnostic.
194 void EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
195 ArrayRef<FixItHint> Hints,
196 const SourceManager &SM);
197
198 /// Emit a record for a CharSourceRange.
199 void EmitCharSourceRange(CharSourceRange R, const SourceManager &SM);
200
201 /// Emit the string information for the category.
202 unsigned getEmitCategory(unsigned category = 0);
203
204 /// Emit the string information for diagnostic flags.
205 unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
206 unsigned DiagID = 0);
207
208 unsigned getEmitDiagnosticFlag(StringRef DiagName);
209
210 /// Emit (lazily) the file string and retrieved the file identifier.
211 unsigned getEmitFile(const char *Filename);
212
213 /// Add SourceLocation information the specified record.
214 void AddLocToRecord(FullSourceLoc Loc, PresumedLoc PLoc,
215 RecordDataImpl &Record, unsigned TokSize = 0);
216
217 /// Add SourceLocation information the specified record.
218 void AddLocToRecord(FullSourceLoc Loc, RecordDataImpl &Record,
219 unsigned TokSize = 0) {
220 AddLocToRecord(Loc, Loc.hasManager() ? Loc.getPresumedLoc() : PresumedLoc(),
221 Record, TokSize);
222 }
223
224 /// Add CharSourceRange information the specified record.
225 void AddCharSourceRangeToRecord(CharSourceRange R, RecordDataImpl &Record,
226 const SourceManager &SM);
227
228 /// Language options, which can differ from one clone of this client
229 /// to another.
230 const LangOptions *LangOpts;
231
232 /// Whether this is the original instance (rather than one of its
233 /// clones), responsible for writing the file at the end.
234 bool OriginalInstance;
235
236 /// Whether this instance should aggregate diagnostics that are
237 /// generated from child processes.
238 bool MergeChildRecords;
239
240 /// State that is shared among the various clones of this diagnostic
241 /// consumer.
242 struct SharedState {
243 SharedState(StringRef File, DiagnosticOptions *Diags)
244 : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),
245 EmittedAnyDiagBlocks(false) {}
246
247 /// Diagnostic options.
248 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
249
250 /// The byte buffer for the serialized content.
251 SmallString<1024> Buffer;
252
253 /// The BitStreamWriter for the serialized diagnostics.
254 llvm::BitstreamWriter Stream;
255
256 /// The name of the diagnostics file.
257 std::string OutputFile;
258
259 /// The set of constructed record abbreviations.
260 AbbreviationMap Abbrevs;
261
262 /// A utility buffer for constructing record content.
263 RecordData Record;
264
265 /// A text buffer for rendering diagnostic text.
266 SmallString<256> diagBuf;
267
268 /// The collection of diagnostic categories used.
269 llvm::DenseSet<unsigned> Categories;
270
271 /// The collection of files used.
272 llvm::DenseMap<const char *, unsigned> Files;
273
274 typedef llvm::DenseMap<const void *, std::pair<unsigned, StringRef> >
275 DiagFlagsTy;
276
277 /// Map for uniquing strings.
278 DiagFlagsTy DiagFlags;
279
280 /// Whether we have already started emission of any DIAG blocks. Once
281 /// this becomes \c true, we never close a DIAG block until we know that we're
282 /// starting another one or we're done.
283 bool EmittedAnyDiagBlocks;
284
285 /// Engine for emitting diagnostics about the diagnostics.
286 std::unique_ptr<DiagnosticsEngine> MetaDiagnostics;
287 };
288
289 /// State shared among the various clones of this diagnostic consumer.
290 std::shared_ptr<SharedState> State;
291};
292} // end anonymous namespace
293
294namespace clang {
295namespace serialized_diags {
296std::unique_ptr<DiagnosticConsumer>
297create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords) {
298 return llvm::make_unique<SDiagsWriter>(OutputFile, Diags, MergeChildRecords);
299}
300
301} // end namespace serialized_diags
302} // end namespace clang
303
304//===----------------------------------------------------------------------===//
305// Serialization methods.
306//===----------------------------------------------------------------------===//
307
308/// Emits a block ID in the BLOCKINFO block.
309static void EmitBlockID(unsigned ID, const char *Name,
310 llvm::BitstreamWriter &Stream,
311 RecordDataImpl &Record) {
312 Record.clear();
313 Record.push_back(ID);
314 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
315
316 // Emit the block name if present.
317 if (!Name || Name[0] == 0)
318 return;
319
320 Record.clear();
321
322 while (*Name)
323 Record.push_back(*Name++);
324
325 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
326}
327
328/// Emits a record ID in the BLOCKINFO block.
329static void EmitRecordID(unsigned ID, const char *Name,
330 llvm::BitstreamWriter &Stream,
331 RecordDataImpl &Record){
332 Record.clear();
333 Record.push_back(ID);
334
335 while (*Name)
336 Record.push_back(*Name++);
337
338 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
339}
340
341void SDiagsWriter::AddLocToRecord(FullSourceLoc Loc, PresumedLoc PLoc,
342 RecordDataImpl &Record, unsigned TokSize) {
343 if (PLoc.isInvalid()) {
344 // Emit a "sentinel" location.
345 Record.push_back((unsigned)0); // File.
346 Record.push_back((unsigned)0); // Line.
347 Record.push_back((unsigned)0); // Column.
348 Record.push_back((unsigned)0); // Offset.
349 return;
350 }
351
352 Record.push_back(getEmitFile(PLoc.getFilename()));
353 Record.push_back(PLoc.getLine());
354 Record.push_back(PLoc.getColumn()+TokSize);
355 Record.push_back(Loc.getFileOffset());
356}
357
358void SDiagsWriter::AddCharSourceRangeToRecord(CharSourceRange Range,
359 RecordDataImpl &Record,
360 const SourceManager &SM) {
361 AddLocToRecord(FullSourceLoc(Range.getBegin(), SM), Record);
362 unsigned TokSize = 0;
363 if (Range.isTokenRange())
364 TokSize = Lexer::MeasureTokenLength(Range.getEnd(),
365 SM, *LangOpts);
366
367 AddLocToRecord(FullSourceLoc(Range.getEnd(), SM), Record, TokSize);
368}
369
370unsigned SDiagsWriter::getEmitFile(const char *FileName){
371 if (!FileName)
372 return 0;
373
374 unsigned &entry = State->Files[FileName];
375 if (entry)
376 return entry;
377
378 // Lazily generate the record for the file.
379 entry = State->Files.size();
380 StringRef Name(FileName);
381 RecordData::value_type Record[] = {RECORD_FILENAME, entry, 0 /* For legacy */,
382 0 /* For legacy */, Name.size()};
383 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
384 Name);
385
386 return entry;
387}
388
389void SDiagsWriter::EmitCharSourceRange(CharSourceRange R,
390 const SourceManager &SM) {
391 State->Record.clear();
392 State->Record.push_back(RECORD_SOURCE_RANGE);
393 AddCharSourceRangeToRecord(R, State->Record, SM);
394 State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
395 State->Record);
396}
397
398/// Emits the preamble of the diagnostics file.
399void SDiagsWriter::EmitPreamble() {
400 // Emit the file header.
401 State->Stream.Emit((unsigned)'D', 8);
402 State->Stream.Emit((unsigned)'I', 8);
403 State->Stream.Emit((unsigned)'A', 8);
404 State->Stream.Emit((unsigned)'G', 8);
405
406 EmitBlockInfoBlock();
407 EmitMetaBlock();
408}
409
410static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev &Abbrev) {
411 using namespace llvm;
412 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // File ID.
413 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line.
414 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column.
415 Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset;
416}
417
418static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev &Abbrev) {
419 AddSourceLocationAbbrev(Abbrev);
420 AddSourceLocationAbbrev(Abbrev);
421}
422
423void SDiagsWriter::EmitBlockInfoBlock() {
424 State->Stream.EnterBlockInfoBlock();
425
426 using namespace llvm;
427 llvm::BitstreamWriter &Stream = State->Stream;
428 RecordData &Record = State->Record;
429 AbbreviationMap &Abbrevs = State->Abbrevs;
430
431 // ==---------------------------------------------------------------------==//
432 // The subsequent records and Abbrevs are for the "Meta" block.
433 // ==---------------------------------------------------------------------==//
434
435 EmitBlockID(BLOCK_META, "Meta", Stream, Record);
436 EmitRecordID(RECORD_VERSION, "Version", Stream, Record);
437 auto Abbrev = std::make_shared<BitCodeAbbrev>();
438 Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION));
439 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
440 Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));
441
442 // ==---------------------------------------------------------------------==//
443 // The subsequent records and Abbrevs are for the "Diagnostic" block.
444 // ==---------------------------------------------------------------------==//
445
446 EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
447 EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
448 EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
449 EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
450 EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
451 EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
452 EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);
453
454 // Emit abbreviation for RECORD_DIAG.
455 Abbrev = std::make_shared<BitCodeAbbrev>();
456 Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
457 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level.
458 AddSourceLocationAbbrev(*Abbrev);
459 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
460 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
461 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // Text size.
462 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
463 Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
464
465 // Emit abbreviation for RECORD_CATEGORY.
466 Abbrev = std::make_shared<BitCodeAbbrev>();
467 Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
468 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
469 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size.
470 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text.
471 Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
472
473 // Emit abbreviation for RECORD_SOURCE_RANGE.
474 Abbrev = std::make_shared<BitCodeAbbrev>();
475 Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
476 AddRangeLocationAbbrev(*Abbrev);
477 Abbrevs.set(RECORD_SOURCE_RANGE,
478 Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
479
480 // Emit the abbreviation for RECORD_DIAG_FLAG.
481 Abbrev = std::make_shared<BitCodeAbbrev>();
482 Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
483 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
484 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
485 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
486 Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
487 Abbrev));
488
489 // Emit the abbreviation for RECORD_FILENAME.
490 Abbrev = std::make_shared<BitCodeAbbrev>();
491 Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
492 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID.
493 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size.
494 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modification time.
495 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
496 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
497 Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
498 Abbrev));
499
500 // Emit the abbreviation for RECORD_FIXIT.
501 Abbrev = std::make_shared<BitCodeAbbrev>();
502 Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT));
503 AddRangeLocationAbbrev(*Abbrev);
504 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
505 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // FixIt text.
506 Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
507 Abbrev));
508
509 Stream.ExitBlock();
510}
511
512void SDiagsWriter::EmitMetaBlock() {
513 llvm::BitstreamWriter &Stream = State->Stream;
514 AbbreviationMap &Abbrevs = State->Abbrevs;
515
516 Stream.EnterSubblock(BLOCK_META, 3);
517 RecordData::value_type Record[] = {RECORD_VERSION, VersionNumber};
518 Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);
519 Stream.ExitBlock();
520}
521
522unsigned SDiagsWriter::getEmitCategory(unsigned int category) {
523 if (!State->Categories.insert(category).second)
524 return category;
525
526 // We use a local version of 'Record' so that we can be generating
527 // another record when we lazily generate one for the category entry.
528 StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
529 RecordData::value_type Record[] = {RECORD_CATEGORY, category, catName.size()};
530 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
531 catName);
532
533 return category;
534}
535
536unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
537 unsigned DiagID) {
538 if (DiagLevel == DiagnosticsEngine::Note)
539 return 0; // No flag for notes.
540
541 StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID);
542 return getEmitDiagnosticFlag(FlagName);
543}
544
545unsigned SDiagsWriter::getEmitDiagnosticFlag(StringRef FlagName) {
546 if (FlagName.empty())
547 return 0;
548
549 // Here we assume that FlagName points to static data whose pointer
550 // value is fixed. This allows us to unique by diagnostic groups.
551 const void *data = FlagName.data();
552 std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
553 if (entry.first == 0) {
554 entry.first = State->DiagFlags.size();
555 entry.second = FlagName;
556
557 // Lazily emit the string in a separate record.
558 RecordData::value_type Record[] = {RECORD_DIAG_FLAG, entry.first,
559 FlagName.size()};
560 State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
561 Record, FlagName);
562 }
563
564 return entry.first;
565}
566
567void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
568 const Diagnostic &Info) {
569 // Enter the block for a non-note diagnostic immediately, rather than waiting
570 // for beginDiagnostic, in case associated notes are emitted before we get
571 // there.
572 if (DiagLevel != DiagnosticsEngine::Note) {
573 if (State->EmittedAnyDiagBlocks)
574 ExitDiagBlock();
575
576 EnterDiagBlock();
577 State->EmittedAnyDiagBlocks = true;
578 }
579
580 // Compute the diagnostic text.
581 State->diagBuf.clear();
582 Info.FormatDiagnostic(State->diagBuf);
583
584 if (Info.getLocation().isInvalid()) {
585 // Special-case diagnostics with no location. We may not have entered a
586 // source file in this case, so we can't use the normal DiagnosticsRenderer
587 // machinery.
588
589 // Make sure we bracket all notes as "sub-diagnostics". This matches
590 // the behavior in SDiagsRenderer::emitDiagnostic().
591 if (DiagLevel == DiagnosticsEngine::Note)
592 EnterDiagBlock();
593
594 EmitDiagnosticMessage(FullSourceLoc(), PresumedLoc(), DiagLevel,
595 State->diagBuf, &Info);
596
597 if (DiagLevel == DiagnosticsEngine::Note)
598 ExitDiagBlock();
599
600 return;
601 }
602
603 assert(Info.hasSourceManager() && LangOpts &&(static_cast <bool> (Info.hasSourceManager() &&
LangOpts && "Unexpected diagnostic with valid location outside of a source file"
) ? void (0) : __assert_fail ("Info.hasSourceManager() && LangOpts && \"Unexpected diagnostic with valid location outside of a source file\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp"
, 604, __extension__ __PRETTY_FUNCTION__))
604 "Unexpected diagnostic with valid location outside of a source file")(static_cast <bool> (Info.hasSourceManager() &&
LangOpts && "Unexpected diagnostic with valid location outside of a source file"
) ? void (0) : __assert_fail ("Info.hasSourceManager() && LangOpts && \"Unexpected diagnostic with valid location outside of a source file\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp"
, 604, __extension__ __PRETTY_FUNCTION__));
605 SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
606 Renderer.emitDiagnostic(
607 FullSourceLoc(Info.getLocation(), Info.getSourceManager()), DiagLevel,
608 State->diagBuf, Info.getRanges(), Info.getFixItHints(), &Info);
609}
610
611static serialized_diags::Level getStableLevel(DiagnosticsEngine::Level Level) {
612 switch (Level) {
613#define CASE(X) case DiagnosticsEngine::X: return serialized_diags::X;
614 CASE(Ignored)
615 CASE(Note)
616 CASE(Remark)
617 CASE(Warning)
618 CASE(Error)
619 CASE(Fatal)
620#undef CASE
621 }
622
623 llvm_unreachable("invalid diagnostic level")::llvm::llvm_unreachable_internal("invalid diagnostic level",
"/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp"
, 623);
624}
625
626void SDiagsWriter::EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
627 DiagnosticsEngine::Level Level,
628 StringRef Message,
629 DiagOrStoredDiag D) {
630 llvm::BitstreamWriter &Stream = State->Stream;
631 RecordData &Record = State->Record;
632 AbbreviationMap &Abbrevs = State->Abbrevs;
633
634 // Emit the RECORD_DIAG record.
635 Record.clear();
636 Record.push_back(RECORD_DIAG);
637 Record.push_back(getStableLevel(Level));
638 AddLocToRecord(Loc, PLoc, Record);
639
640 if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) {
641 // Emit the category string lazily and get the category ID.
642 unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID());
643 Record.push_back(getEmitCategory(DiagID));
644 // Emit the diagnostic flag string lazily and get the mapped ID.
645 Record.push_back(getEmitDiagnosticFlag(Level, Info->getID()));
646 } else {
647 Record.push_back(getEmitCategory());
648 Record.push_back(getEmitDiagnosticFlag(Level));
649 }
650
651 Record.push_back(Message.size());
652 Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);
653}
654
655void SDiagsRenderer::emitDiagnosticMessage(
656 FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
657 StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
658 DiagOrStoredDiag D) {
659 Writer.EmitDiagnosticMessage(Loc, PLoc, Level, Message, D);
660}
661
662void SDiagsWriter::EnterDiagBlock() {
663 State->Stream.EnterSubblock(BLOCK_DIAG, 4);
664}
665
666void SDiagsWriter::ExitDiagBlock() {
667 State->Stream.ExitBlock();
668}
669
670void SDiagsRenderer::beginDiagnostic(DiagOrStoredDiag D,
671 DiagnosticsEngine::Level Level) {
672 if (Level == DiagnosticsEngine::Note)
673 Writer.EnterDiagBlock();
674}
675
676void SDiagsRenderer::endDiagnostic(DiagOrStoredDiag D,
677 DiagnosticsEngine::Level Level) {
678 // Only end note diagnostics here, because we can't be sure when we've seen
679 // the last note associated with a non-note diagnostic.
680 if (Level == DiagnosticsEngine::Note)
681 Writer.ExitDiagBlock();
682}
683
684void SDiagsWriter::EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges,
685 ArrayRef<FixItHint> Hints,
686 const SourceManager &SM) {
687 llvm::BitstreamWriter &Stream = State->Stream;
688 RecordData &Record = State->Record;
689 AbbreviationMap &Abbrevs = State->Abbrevs;
690
691 // Emit Source Ranges.
692 for (ArrayRef<CharSourceRange>::iterator I = Ranges.begin(), E = Ranges.end();
693 I != E; ++I)
694 if (I->isValid())
695 EmitCharSourceRange(*I, SM);
696
697 // Emit FixIts.
698 for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
699 I != E; ++I) {
700 const FixItHint &Fix = *I;
701 if (Fix.isNull())
702 continue;
703 Record.clear();
704 Record.push_back(RECORD_FIXIT);
705 AddCharSourceRangeToRecord(Fix.RemoveRange, Record, SM);
706 Record.push_back(Fix.CodeToInsert.size());
707 Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
708 Fix.CodeToInsert);
709 }
710}
711
712void SDiagsRenderer::emitCodeContext(FullSourceLoc Loc,
713 DiagnosticsEngine::Level Level,
714 SmallVectorImpl<CharSourceRange> &Ranges,
715 ArrayRef<FixItHint> Hints) {
716 Writer.EmitCodeContext(Ranges, Hints, Loc.getManager());
717}
718
719void SDiagsRenderer::emitNote(FullSourceLoc Loc, StringRef Message) {
720 Writer.EnterDiagBlock();
721 PresumedLoc PLoc = Loc.hasManager() ? Loc.getPresumedLoc() : PresumedLoc();
722 Writer.EmitDiagnosticMessage(Loc, PLoc, DiagnosticsEngine::Note, Message,
723 DiagOrStoredDiag());
724 Writer.ExitDiagBlock();
725}
726
727DiagnosticsEngine *SDiagsWriter::getMetaDiags() {
728 // FIXME: It's slightly absurd to create a new diagnostics engine here, but
729 // the other options that are available today are worse:
730 //
731 // 1. Teach DiagnosticsConsumers to emit diagnostics to the engine they are a
732 // part of. The DiagnosticsEngine would need to know not to send
733 // diagnostics back to the consumer that failed. This would require us to
734 // rework ChainedDiagnosticsConsumer and teach the engine about multiple
735 // consumers, which is difficult today because most APIs interface with
736 // consumers rather than the engine itself.
737 //
738 // 2. Pass a DiagnosticsEngine to SDiagsWriter on creation - this would need
739 // to be distinct from the engine the writer was being added to and would
740 // normally not be used.
741 if (!State->MetaDiagnostics) {
3
←
Taking true branch
→
742 IntrusiveRefCntPtr<DiagnosticIDs> IDs(new DiagnosticIDs());
4
←
Memory is allocated
→
743 auto Client =
744 new TextDiagnosticPrinter(llvm::errs(), State->DiagOpts.get());
745 State->MetaDiagnostics = llvm::make_unique<DiagnosticsEngine>(
746 IDs, State->DiagOpts.get(), Client);
747 }
748 return State->MetaDiagnostics.get();
5
←
Potential leak of memory pointed to by field 'Obj'
749}
750
751void SDiagsWriter::RemoveOldDiagnostics() {
752 if (!llvm::sys::fs::remove(State->OutputFile))
1
Taking false branch
→
753 return;
754
755 getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
2
←
Calling 'SDiagsWriter::getMetaDiags'
→
756 // Disable merging child records, as whatever is in this file may be
757 // misleading.
758 MergeChildRecords = false;
759}
760
761void SDiagsWriter::finish() {
762 // The original instance is responsible for writing the file.
763 if (!OriginalInstance)
764 return;
765
766 // Finish off any diagnostic we were in the process of emitting.
767 if (State->EmittedAnyDiagBlocks)
768 ExitDiagBlock();
769
770 if (MergeChildRecords) {
771 if (!State->EmittedAnyDiagBlocks)
772 // We have no diagnostics of our own, so we can just leave the child
773 // process' output alone
774 return;
775
776 if (llvm::sys::fs::exists(State->OutputFile))
777 if (SDiagsMerger(*this).mergeRecordsFromFile(State->OutputFile.c_str()))
778 getMetaDiags()->Report(diag::warn_fe_serialized_diag_merge_failure);
779 }
780
781 std::error_code EC;
782 auto OS = llvm::make_unique<llvm::raw_fd_ostream>(State->OutputFile.c_str(),
783 EC, llvm::sys::fs::F_None);
784 if (EC) {
785 getMetaDiags()->Report(diag::warn_fe_serialized_diag_failure)
786 << State->OutputFile << EC.message();
787 return;
788 }
789
790 // Write the generated bitstream to "Out".
791 OS->write((char *)&State->Buffer.front(), State->Buffer.size());
792 OS->flush();
793}
794
795std::error_code SDiagsMerger::visitStartOfDiagnostic() {
796 Writer.EnterDiagBlock();
797 return std::error_code();
798}
799
800std::error_code SDiagsMerger::visitEndOfDiagnostic() {
801 Writer.ExitDiagBlock();
802 return std::error_code();
803}
804
805std::error_code
806SDiagsMerger::visitSourceRangeRecord(const serialized_diags::Location &Start,
807 const serialized_diags::Location &End) {
808 RecordData::value_type Record[] = {
809 RECORD_SOURCE_RANGE, FileLookup[Start.FileID], Start.Line, Start.Col,
810 Start.Offset, FileLookup[End.FileID], End.Line, End.Col, End.Offset};
811 Writer.State->Stream.EmitRecordWithAbbrev(
812 Writer.State->Abbrevs.get(RECORD_SOURCE_RANGE), Record);
813 return std::error_code();
814}
815
816std::error_code SDiagsMerger::visitDiagnosticRecord(
817 unsigned Severity, const serialized_diags::Location &Location,
818 unsigned Category, unsigned Flag, StringRef Message) {
819 RecordData::value_type Record[] = {
820 RECORD_DIAG, Severity, FileLookup[Location.FileID], Location.Line,
821 Location.Col, Location.Offset, CategoryLookup[Category],
822 Flag ? DiagFlagLookup[Flag] : 0, Message.size()};
823
824 Writer.State->Stream.EmitRecordWithBlob(
825 Writer.State->Abbrevs.get(RECORD_DIAG), Record, Message);
826 return std::error_code();
827}
828
829std::error_code
830SDiagsMerger::visitFixitRecord(const serialized_diags::Location &Start,
831 const serialized_diags::Location &End,
832 StringRef Text) {
833 RecordData::value_type Record[] = {RECORD_FIXIT, FileLookup[Start.FileID],
834 Start.Line, Start.Col, Start.Offset,
835 FileLookup[End.FileID], End.Line, End.Col,
836 End.Offset, Text.size()};
837
838 Writer.State->Stream.EmitRecordWithBlob(
839 Writer.State->Abbrevs.get(RECORD_FIXIT), Record, Text);
840 return std::error_code();
841}
842
843std::error_code SDiagsMerger::visitFilenameRecord(unsigned ID, unsigned Size,
844 unsigned Timestamp,
845 StringRef Name) {
846 FileLookup[ID] = Writer.getEmitFile(Name.str().c_str());
847 return std::error_code();
848}
849
850std::error_code SDiagsMerger::visitCategoryRecord(unsigned ID, StringRef Name) {
851 CategoryLookup[ID] = Writer.getEmitCategory(ID);
852 return std::error_code();
853}
854
855std::error_code SDiagsMerger::visitDiagFlagRecord(unsigned ID, StringRef Name) {
856 DiagFlagLookup[ID] = Writer.getEmitDiagnosticFlag(Name);
857 return std::error_code();
858}