Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 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 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 10 | #include "clang/Frontend/SerializedDiagnosticPrinter.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 11 | #include "clang/Basic/Diagnostic.h" |
| 12 | #include "clang/Basic/DiagnosticOptions.h" |
| 13 | #include "clang/Basic/FileManager.h" |
| 14 | #include "clang/Basic/SourceManager.h" |
| 15 | #include "clang/Basic/Version.h" |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 16 | #include "clang/Frontend/DiagnosticRenderer.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 17 | #include "clang/Lex/Lexer.h" |
| 18 | #include "llvm/ADT/DenseSet.h" |
| 19 | #include "llvm/ADT/SmallString.h" |
| 20 | #include "llvm/ADT/StringRef.h" |
| 21 | #include "llvm/Support/raw_ostream.h" |
| 22 | #include <vector> |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 23 | |
| 24 | using namespace clang; |
Ted Kremenek | fdd0ced | 2011-11-05 00:09:57 +0000 | [diff] [blame] | 25 | using namespace clang::serialized_diags; |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 26 | |
| 27 | namespace { |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 28 | |
| 29 | class AbbreviationMap { |
| 30 | llvm::DenseMap<unsigned, unsigned> Abbrevs; |
| 31 | public: |
| 32 | AbbreviationMap() {} |
| 33 | |
| 34 | void set(unsigned recordID, unsigned abbrevID) { |
| 35 | assert(Abbrevs.find(recordID) == Abbrevs.end() |
| 36 | && "Abbreviation already set."); |
| 37 | Abbrevs[recordID] = abbrevID; |
| 38 | } |
| 39 | |
| 40 | unsigned get(unsigned recordID) { |
| 41 | assert(Abbrevs.find(recordID) != Abbrevs.end() && |
| 42 | "Abbreviation not set."); |
| 43 | return Abbrevs[recordID]; |
| 44 | } |
| 45 | }; |
| 46 | |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 47 | typedef SmallVector<uint64_t, 64> RecordData; |
| 48 | typedef SmallVectorImpl<uint64_t> RecordDataImpl; |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 49 | |
| 50 | class SDiagsWriter; |
| 51 | |
Ted Kremenek | 8be51ea | 2012-02-14 02:46:00 +0000 | [diff] [blame] | 52 | class SDiagsRenderer : public DiagnosticNoteRenderer { |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 53 | SDiagsWriter &Writer; |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 54 | public: |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 55 | SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts, |
Douglas Gregor | 02c23eb | 2012-10-23 22:26:28 +0000 | [diff] [blame] | 56 | DiagnosticOptions *DiagOpts) |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 57 | : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {} |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 58 | |
| 59 | virtual ~SDiagsRenderer() {} |
| 60 | |
| 61 | protected: |
| 62 | virtual void emitDiagnosticMessage(SourceLocation Loc, |
| 63 | PresumedLoc PLoc, |
| 64 | DiagnosticsEngine::Level Level, |
| 65 | StringRef Message, |
| 66 | ArrayRef<CharSourceRange> Ranges, |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 67 | const SourceManager *SM, |
Ted Kremenek | 8be51ea | 2012-02-14 02:46:00 +0000 | [diff] [blame] | 68 | DiagOrStoredDiag D); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 69 | |
| 70 | virtual void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc, |
| 71 | DiagnosticsEngine::Level Level, |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 72 | ArrayRef<CharSourceRange> Ranges, |
| 73 | const SourceManager &SM) {} |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 74 | |
| 75 | virtual void emitNote(SourceLocation Loc, StringRef Message, |
| 76 | const SourceManager *SM); |
| 77 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 78 | virtual void emitCodeContext(SourceLocation Loc, |
| 79 | DiagnosticsEngine::Level Level, |
| 80 | SmallVectorImpl<CharSourceRange>& Ranges, |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 81 | ArrayRef<FixItHint> Hints, |
| 82 | const SourceManager &SM); |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 83 | |
Ted Kremenek | 8be51ea | 2012-02-14 02:46:00 +0000 | [diff] [blame] | 84 | virtual void beginDiagnostic(DiagOrStoredDiag D, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 85 | DiagnosticsEngine::Level Level); |
Ted Kremenek | 8be51ea | 2012-02-14 02:46:00 +0000 | [diff] [blame] | 86 | virtual void endDiagnostic(DiagOrStoredDiag D, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 87 | DiagnosticsEngine::Level Level); |
| 88 | }; |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 89 | |
| 90 | class SDiagsWriter : public DiagnosticConsumer { |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 91 | friend class SDiagsRenderer; |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 92 | |
| 93 | struct SharedState; |
| 94 | |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 95 | explicit SDiagsWriter(IntrusiveRefCntPtr<SharedState> State) |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 96 | : LangOpts(0), OriginalInstance(false), State(State) { } |
| 97 | |
| 98 | public: |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 99 | SDiagsWriter(raw_ostream *os, DiagnosticOptions *diags) |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 100 | : LangOpts(0), OriginalInstance(true), State(new SharedState(os, diags)) |
| 101 | { |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 102 | EmitPreamble(); |
Devang Patel | 02ae32a | 2011-11-15 01:30:40 +0000 | [diff] [blame] | 103 | } |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 104 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 105 | ~SDiagsWriter() {} |
| 106 | |
| 107 | void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
| 108 | const Diagnostic &Info); |
| 109 | |
Ted Kremenek | 1532217 | 2011-11-10 08:43:12 +0000 | [diff] [blame] | 110 | void BeginSourceFile(const LangOptions &LO, |
| 111 | const Preprocessor *PP) { |
| 112 | LangOpts = &LO; |
| 113 | } |
Argyrios Kyrtzidis | 29f2787 | 2011-12-07 05:52:12 +0000 | [diff] [blame] | 114 | |
| 115 | virtual void finish(); |
| 116 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 117 | DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 118 | return new SDiagsWriter(State); |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 119 | } |
| 120 | |
| 121 | private: |
| 122 | /// \brief Emit the preamble for the serialized diagnostics. |
| 123 | void EmitPreamble(); |
| 124 | |
| 125 | /// \brief Emit the BLOCKINFO block. |
| 126 | void EmitBlockInfoBlock(); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 127 | |
Ted Kremenek | 0b69aa8 | 2011-11-08 20:27:29 +0000 | [diff] [blame] | 128 | /// \brief Emit the META data block. |
| 129 | void EmitMetaBlock(); |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 130 | |
| 131 | /// \brief Start a DIAG block. |
| 132 | void EnterDiagBlock(); |
| 133 | |
| 134 | /// \brief End a DIAG block. |
| 135 | void ExitDiagBlock(); |
| 136 | |
| 137 | /// \brief Emit a DIAG record. |
| 138 | void EmitDiagnosticMessage(SourceLocation Loc, |
| 139 | PresumedLoc PLoc, |
| 140 | DiagnosticsEngine::Level Level, |
| 141 | StringRef Message, |
| 142 | const SourceManager *SM, |
| 143 | DiagOrStoredDiag D); |
| 144 | |
| 145 | /// \brief Emit FIXIT and SOURCE_RANGE records for a diagnostic. |
| 146 | void EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges, |
| 147 | ArrayRef<FixItHint> Hints, |
| 148 | const SourceManager &SM); |
| 149 | |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 150 | /// \brief Emit a record for a CharSourceRange. |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 151 | void EmitCharSourceRange(CharSourceRange R, const SourceManager &SM); |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 152 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 153 | /// \brief Emit the string information for the category. |
| 154 | unsigned getEmitCategory(unsigned category = 0); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 155 | |
| 156 | /// \brief Emit the string information for diagnostic flags. |
| 157 | unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 158 | unsigned DiagID = 0); |
Ted Kremenek | 0dbadc4 | 2011-11-05 00:10:04 +0000 | [diff] [blame] | 159 | |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 160 | /// \brief Emit (lazily) the file string and retrieved the file identifier. |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 161 | unsigned getEmitFile(const char *Filename); |
| 162 | |
| 163 | /// \brief Add SourceLocation information the specified record. |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 164 | void AddLocToRecord(SourceLocation Loc, const SourceManager *SM, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 165 | PresumedLoc PLoc, RecordDataImpl &Record, |
| 166 | unsigned TokSize = 0); |
| 167 | |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 168 | /// \brief Add SourceLocation information the specified record. |
Ted Kremenek | 1532217 | 2011-11-10 08:43:12 +0000 | [diff] [blame] | 169 | void AddLocToRecord(SourceLocation Loc, RecordDataImpl &Record, |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 170 | const SourceManager *SM, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 171 | unsigned TokSize = 0) { |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 172 | AddLocToRecord(Loc, SM, SM ? SM->getPresumedLoc(Loc) : PresumedLoc(), |
| 173 | Record, TokSize); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 174 | } |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 175 | |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 176 | /// \brief Add CharSourceRange information the specified record. |
Argyrios Kyrtzidis | 29f2787 | 2011-12-07 05:52:12 +0000 | [diff] [blame] | 177 | void AddCharSourceRangeToRecord(CharSourceRange R, RecordDataImpl &Record, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 178 | const SourceManager &SM); |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 179 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 180 | /// \brief The version of the diagnostics file. |
| 181 | enum { Version = 1 }; |
| 182 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 183 | /// \brief Language options, which can differ from one clone of this client |
| 184 | /// to another. |
Ted Kremenek | 1532217 | 2011-11-10 08:43:12 +0000 | [diff] [blame] | 185 | const LangOptions *LangOpts; |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 186 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 187 | /// \brief Whether this is the original instance (rather than one of its |
| 188 | /// clones), responsible for writing the file at the end. |
| 189 | bool OriginalInstance; |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 190 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 191 | /// \brief State that is shared among the various clones of this diagnostic |
| 192 | /// consumer. |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 193 | struct SharedState : RefCountedBase<SharedState> { |
| 194 | SharedState(raw_ostream *os, DiagnosticOptions *diags) |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 195 | : DiagOpts(diags), Stream(Buffer), OS(os), EmittedAnyDiagBlocks(false) { } |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 196 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 197 | /// \brief Diagnostic options. |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 198 | IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts; |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 199 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 200 | /// \brief The byte buffer for the serialized content. |
| 201 | SmallString<1024> Buffer; |
Ted Kremenek | 45d9275 | 2011-11-05 00:09:50 +0000 | [diff] [blame] | 202 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 203 | /// \brief The BitStreamWriter for the serialized diagnostics. |
| 204 | llvm::BitstreamWriter Stream; |
Ted Kremenek | 45d9275 | 2011-11-05 00:09:50 +0000 | [diff] [blame] | 205 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 206 | /// \brief The name of the diagnostics file. |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 207 | OwningPtr<raw_ostream> OS; |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 208 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 209 | /// \brief The set of constructed record abbreviations. |
| 210 | AbbreviationMap Abbrevs; |
| 211 | |
| 212 | /// \brief A utility buffer for constructing record content. |
| 213 | RecordData Record; |
| 214 | |
| 215 | /// \brief A text buffer for rendering diagnostic text. |
| 216 | SmallString<256> diagBuf; |
| 217 | |
| 218 | /// \brief The collection of diagnostic categories used. |
| 219 | llvm::DenseSet<unsigned> Categories; |
| 220 | |
| 221 | /// \brief The collection of files used. |
| 222 | llvm::DenseMap<const char *, unsigned> Files; |
| 223 | |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 224 | typedef llvm::DenseMap<const void *, std::pair<unsigned, StringRef> > |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 225 | DiagFlagsTy; |
| 226 | |
| 227 | /// \brief Map for uniquing strings. |
| 228 | DiagFlagsTy DiagFlags; |
| 229 | |
| 230 | /// \brief Whether we have already started emission of any DIAG blocks. Once |
| 231 | /// this becomes \c true, we never close a DIAG block until we know that we're |
| 232 | /// starting another one or we're done. |
| 233 | bool EmittedAnyDiagBlocks; |
| 234 | }; |
| 235 | |
| 236 | /// \brief State shared among the various clones of this diagnostic consumer. |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 237 | IntrusiveRefCntPtr<SharedState> State; |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 238 | }; |
| 239 | } // end anonymous namespace |
| 240 | |
| 241 | namespace clang { |
| 242 | namespace serialized_diags { |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 243 | DiagnosticConsumer *create(raw_ostream *OS, DiagnosticOptions *diags) { |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 244 | return new SDiagsWriter(OS, diags); |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 245 | } |
| 246 | } // end namespace serialized_diags |
| 247 | } // end namespace clang |
| 248 | |
| 249 | //===----------------------------------------------------------------------===// |
| 250 | // Serialization methods. |
| 251 | //===----------------------------------------------------------------------===// |
| 252 | |
| 253 | /// \brief Emits a block ID in the BLOCKINFO block. |
| 254 | static void EmitBlockID(unsigned ID, const char *Name, |
| 255 | llvm::BitstreamWriter &Stream, |
| 256 | RecordDataImpl &Record) { |
| 257 | Record.clear(); |
| 258 | Record.push_back(ID); |
| 259 | Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); |
| 260 | |
| 261 | // Emit the block name if present. |
| 262 | if (Name == 0 || Name[0] == 0) |
| 263 | return; |
| 264 | |
| 265 | Record.clear(); |
| 266 | |
| 267 | while (*Name) |
| 268 | Record.push_back(*Name++); |
| 269 | |
| 270 | Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); |
| 271 | } |
| 272 | |
| 273 | /// \brief Emits a record ID in the BLOCKINFO block. |
| 274 | static void EmitRecordID(unsigned ID, const char *Name, |
| 275 | llvm::BitstreamWriter &Stream, |
| 276 | RecordDataImpl &Record){ |
| 277 | Record.clear(); |
| 278 | Record.push_back(ID); |
| 279 | |
| 280 | while (*Name) |
| 281 | Record.push_back(*Name++); |
| 282 | |
| 283 | Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); |
| 284 | } |
| 285 | |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 286 | void SDiagsWriter::AddLocToRecord(SourceLocation Loc, |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 287 | const SourceManager *SM, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 288 | PresumedLoc PLoc, |
Ted Kremenek | 1532217 | 2011-11-10 08:43:12 +0000 | [diff] [blame] | 289 | RecordDataImpl &Record, |
| 290 | unsigned TokSize) { |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 291 | if (PLoc.isInvalid()) { |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 292 | // Emit a "sentinel" location. |
Ted Kremenek | 1532217 | 2011-11-10 08:43:12 +0000 | [diff] [blame] | 293 | Record.push_back((unsigned)0); // File. |
| 294 | Record.push_back((unsigned)0); // Line. |
| 295 | Record.push_back((unsigned)0); // Column. |
| 296 | Record.push_back((unsigned)0); // Offset. |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 297 | return; |
| 298 | } |
| 299 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 300 | Record.push_back(getEmitFile(PLoc.getFilename())); |
| 301 | Record.push_back(PLoc.getLine()); |
| 302 | Record.push_back(PLoc.getColumn()+TokSize); |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 303 | Record.push_back(SM->getFileOffset(Loc)); |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 304 | } |
| 305 | |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 306 | void SDiagsWriter::AddCharSourceRangeToRecord(CharSourceRange Range, |
Argyrios Kyrtzidis | 29f2787 | 2011-12-07 05:52:12 +0000 | [diff] [blame] | 307 | RecordDataImpl &Record, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 308 | const SourceManager &SM) { |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 309 | AddLocToRecord(Range.getBegin(), Record, &SM); |
Ted Kremenek | 1532217 | 2011-11-10 08:43:12 +0000 | [diff] [blame] | 310 | unsigned TokSize = 0; |
| 311 | if (Range.isTokenRange()) |
| 312 | TokSize = Lexer::MeasureTokenLength(Range.getEnd(), |
Argyrios Kyrtzidis | 29f2787 | 2011-12-07 05:52:12 +0000 | [diff] [blame] | 313 | SM, *LangOpts); |
Ted Kremenek | 1532217 | 2011-11-10 08:43:12 +0000 | [diff] [blame] | 314 | |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 315 | AddLocToRecord(Range.getEnd(), Record, &SM, TokSize); |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 316 | } |
| 317 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 318 | unsigned SDiagsWriter::getEmitFile(const char *FileName){ |
| 319 | if (!FileName) |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 320 | return 0; |
| 321 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 322 | unsigned &entry = State->Files[FileName]; |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 323 | if (entry) |
| 324 | return entry; |
| 325 | |
| 326 | // Lazily generate the record for the file. |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 327 | entry = State->Files.size(); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 328 | RecordData Record; |
| 329 | Record.push_back(RECORD_FILENAME); |
| 330 | Record.push_back(entry); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 331 | Record.push_back(0); // For legacy. |
| 332 | Record.push_back(0); // For legacy. |
| 333 | StringRef Name(FileName); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 334 | Record.push_back(Name.size()); |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 335 | State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record, |
| 336 | Name); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 337 | |
| 338 | return entry; |
| 339 | } |
| 340 | |
Argyrios Kyrtzidis | 29f2787 | 2011-12-07 05:52:12 +0000 | [diff] [blame] | 341 | void SDiagsWriter::EmitCharSourceRange(CharSourceRange R, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 342 | const SourceManager &SM) { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 343 | State->Record.clear(); |
| 344 | State->Record.push_back(RECORD_SOURCE_RANGE); |
| 345 | AddCharSourceRangeToRecord(R, State->Record, SM); |
| 346 | State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE), |
| 347 | State->Record); |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 348 | } |
| 349 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 350 | /// \brief Emits the preamble of the diagnostics file. |
| 351 | void SDiagsWriter::EmitPreamble() { |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 352 | // Emit the file header. |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 353 | State->Stream.Emit((unsigned)'D', 8); |
| 354 | State->Stream.Emit((unsigned)'I', 8); |
| 355 | State->Stream.Emit((unsigned)'A', 8); |
| 356 | State->Stream.Emit((unsigned)'G', 8); |
Ted Kremenek | 069f9c2 | 2011-11-05 00:09:53 +0000 | [diff] [blame] | 357 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 358 | EmitBlockInfoBlock(); |
Ted Kremenek | 0b69aa8 | 2011-11-08 20:27:29 +0000 | [diff] [blame] | 359 | EmitMetaBlock(); |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 360 | } |
| 361 | |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 362 | static void AddSourceLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) { |
| 363 | using namespace llvm; |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 364 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // File ID. |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 365 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line. |
| 366 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column. |
| 367 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Offset; |
| 368 | } |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 369 | |
| 370 | static void AddRangeLocationAbbrev(llvm::BitCodeAbbrev *Abbrev) { |
| 371 | AddSourceLocationAbbrev(Abbrev); |
| 372 | AddSourceLocationAbbrev(Abbrev); |
| 373 | } |
| 374 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 375 | void SDiagsWriter::EmitBlockInfoBlock() { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 376 | State->Stream.EnterBlockInfoBlock(3); |
Ted Kremenek | 0b69aa8 | 2011-11-08 20:27:29 +0000 | [diff] [blame] | 377 | |
| 378 | using namespace llvm; |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 379 | llvm::BitstreamWriter &Stream = State->Stream; |
| 380 | RecordData &Record = State->Record; |
| 381 | AbbreviationMap &Abbrevs = State->Abbrevs; |
Ted Kremenek | 0b69aa8 | 2011-11-08 20:27:29 +0000 | [diff] [blame] | 382 | |
| 383 | // ==---------------------------------------------------------------------==// |
| 384 | // The subsequent records and Abbrevs are for the "Meta" block. |
| 385 | // ==---------------------------------------------------------------------==// |
| 386 | |
| 387 | EmitBlockID(BLOCK_META, "Meta", Stream, Record); |
| 388 | EmitRecordID(RECORD_VERSION, "Version", Stream, Record); |
| 389 | BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); |
| 390 | Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION)); |
| 391 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); |
| 392 | Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev)); |
| 393 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 394 | // ==---------------------------------------------------------------------==// |
| 395 | // The subsequent records and Abbrevs are for the "Diagnostic" block. |
| 396 | // ==---------------------------------------------------------------------==// |
| 397 | |
Ted Kremenek | 45d9275 | 2011-11-05 00:09:50 +0000 | [diff] [blame] | 398 | EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record); |
| 399 | EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record); |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 400 | EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record); |
Ted Kremenek | 0dbadc4 | 2011-11-05 00:10:04 +0000 | [diff] [blame] | 401 | EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 402 | EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 403 | EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record); |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 404 | EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 405 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 406 | // Emit abbreviation for RECORD_DIAG. |
Ted Kremenek | 0b69aa8 | 2011-11-08 20:27:29 +0000 | [diff] [blame] | 407 | Abbrev = new BitCodeAbbrev(); |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 408 | Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG)); |
Ted Kremenek | 45d9275 | 2011-11-05 00:09:50 +0000 | [diff] [blame] | 409 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level. |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 410 | AddSourceLocationAbbrev(Abbrev); |
Ted Kremenek | 45d9275 | 2011-11-05 00:09:50 +0000 | [diff] [blame] | 411 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category. |
| 412 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID. |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 413 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size. |
| 414 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text. |
| 415 | Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev)); |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 416 | |
Ted Kremenek | 0dbadc4 | 2011-11-05 00:10:04 +0000 | [diff] [blame] | 417 | // Emit abbrevation for RECORD_CATEGORY. |
| 418 | Abbrev = new BitCodeAbbrev(); |
| 419 | Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY)); |
| 420 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID. |
| 421 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size. |
| 422 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text. |
| 423 | Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev)); |
| 424 | |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 425 | // Emit abbrevation for RECORD_SOURCE_RANGE. |
| 426 | Abbrev = new BitCodeAbbrev(); |
| 427 | Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE)); |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 428 | AddRangeLocationAbbrev(Abbrev); |
Ted Kremenek | 2a20b4f | 2011-11-05 00:10:01 +0000 | [diff] [blame] | 429 | Abbrevs.set(RECORD_SOURCE_RANGE, |
| 430 | Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev)); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 431 | |
| 432 | // Emit the abbreviation for RECORD_DIAG_FLAG. |
| 433 | Abbrev = new BitCodeAbbrev(); |
| 434 | Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG)); |
| 435 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID. |
| 436 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size. |
| 437 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text. |
| 438 | Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, |
| 439 | Abbrev)); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 440 | |
| 441 | // Emit the abbreviation for RECORD_FILENAME. |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 442 | Abbrev = new BitCodeAbbrev(); |
Ted Kremenek | 28eac52 | 2011-11-05 00:09:43 +0000 | [diff] [blame] | 443 | Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME)); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 444 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID. |
| 445 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size. |
| 446 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modifcation time. |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 447 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size. |
| 448 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text. |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 449 | Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 450 | Abbrev)); |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 451 | |
| 452 | // Emit the abbreviation for RECORD_FIXIT. |
| 453 | Abbrev = new BitCodeAbbrev(); |
| 454 | Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT)); |
| 455 | AddRangeLocationAbbrev(Abbrev); |
| 456 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size. |
| 457 | Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // FixIt text. |
| 458 | Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, |
| 459 | Abbrev)); |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 460 | |
| 461 | Stream.ExitBlock(); |
| 462 | } |
| 463 | |
Ted Kremenek | 0b69aa8 | 2011-11-08 20:27:29 +0000 | [diff] [blame] | 464 | void SDiagsWriter::EmitMetaBlock() { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 465 | llvm::BitstreamWriter &Stream = State->Stream; |
| 466 | RecordData &Record = State->Record; |
| 467 | AbbreviationMap &Abbrevs = State->Abbrevs; |
| 468 | |
Ted Kremenek | 0b69aa8 | 2011-11-08 20:27:29 +0000 | [diff] [blame] | 469 | Stream.EnterSubblock(BLOCK_META, 3); |
| 470 | Record.clear(); |
| 471 | Record.push_back(RECORD_VERSION); |
| 472 | Record.push_back(Version); |
| 473 | Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record); |
| 474 | Stream.ExitBlock(); |
| 475 | } |
| 476 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 477 | unsigned SDiagsWriter::getEmitCategory(unsigned int category) { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 478 | if (State->Categories.count(category)) |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 479 | return category; |
| 480 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 481 | State->Categories.insert(category); |
Ted Kremenek | 0dbadc4 | 2011-11-05 00:10:04 +0000 | [diff] [blame] | 482 | |
| 483 | // We use a local version of 'Record' so that we can be generating |
| 484 | // another record when we lazily generate one for the category entry. |
| 485 | RecordData Record; |
| 486 | Record.push_back(RECORD_CATEGORY); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 487 | Record.push_back(category); |
| 488 | StringRef catName = DiagnosticIDs::getCategoryNameFromID(category); |
Ted Kremenek | 0dbadc4 | 2011-11-05 00:10:04 +0000 | [diff] [blame] | 489 | Record.push_back(catName.size()); |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 490 | State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record, |
| 491 | catName); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 492 | |
| 493 | return category; |
| 494 | } |
| 495 | |
| 496 | unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 497 | unsigned DiagID) { |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 498 | if (DiagLevel == DiagnosticsEngine::Note) |
| 499 | return 0; // No flag for notes. |
| 500 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 501 | StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 502 | if (FlagName.empty()) |
| 503 | return 0; |
| 504 | |
| 505 | // Here we assume that FlagName points to static data whose pointer |
| 506 | // value is fixed. This allows us to unique by diagnostic groups. |
| 507 | const void *data = FlagName.data(); |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 508 | std::pair<unsigned, StringRef> &entry = State->DiagFlags[data]; |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 509 | if (entry.first == 0) { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 510 | entry.first = State->DiagFlags.size(); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 511 | entry.second = FlagName; |
| 512 | |
| 513 | // Lazily emit the string in a separate record. |
| 514 | RecordData Record; |
| 515 | Record.push_back(RECORD_DIAG_FLAG); |
| 516 | Record.push_back(entry.first); |
| 517 | Record.push_back(FlagName.size()); |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 518 | State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG), |
| 519 | Record, FlagName); |
Ted Kremenek | 3baf63d | 2011-11-05 00:10:07 +0000 | [diff] [blame] | 520 | } |
| 521 | |
| 522 | return entry.first; |
Ted Kremenek | 0dbadc4 | 2011-11-05 00:10:04 +0000 | [diff] [blame] | 523 | } |
| 524 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 525 | void SDiagsWriter::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
| 526 | const Diagnostic &Info) { |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 527 | // Enter the block for a non-note diagnostic immediately, rather than waiting |
| 528 | // for beginDiagnostic, in case associated notes are emitted before we get |
| 529 | // there. |
Ted Kremenek | 59b6161 | 2011-11-05 00:09:47 +0000 | [diff] [blame] | 530 | if (DiagLevel != DiagnosticsEngine::Note) { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 531 | if (State->EmittedAnyDiagBlocks) |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 532 | ExitDiagBlock(); |
| 533 | |
| 534 | EnterDiagBlock(); |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 535 | State->EmittedAnyDiagBlocks = true; |
Ted Kremenek | 59b6161 | 2011-11-05 00:09:47 +0000 | [diff] [blame] | 536 | } |
Ted Kremenek | 96dcade | 2011-11-05 03:34:23 +0000 | [diff] [blame] | 537 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 538 | // Compute the diagnostic text. |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 539 | State->diagBuf.clear(); |
| 540 | Info.FormatDiagnostic(State->diagBuf); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 541 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 542 | if (Info.getLocation().isInvalid()) { |
| 543 | // Special-case diagnostics with no location. We may not have entered a |
| 544 | // source file in this case, so we can't use the normal DiagnosticsRenderer |
| 545 | // machinery. |
Ted Kremenek | 63631bd | 2013-02-21 21:40:44 +0000 | [diff] [blame] | 546 | |
| 547 | // Make sure we bracket all notes as "sub-diagnostics". This matches |
| 548 | // the behavior in SDiagsRenderer::emitDiagnostic(). |
| 549 | if (DiagLevel == DiagnosticsEngine::Note) |
| 550 | EnterDiagBlock(); |
| 551 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 552 | EmitDiagnosticMessage(SourceLocation(), PresumedLoc(), DiagLevel, |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 553 | State->diagBuf, 0, &Info); |
Ted Kremenek | 63631bd | 2013-02-21 21:40:44 +0000 | [diff] [blame] | 554 | |
| 555 | if (DiagLevel == DiagnosticsEngine::Note) |
| 556 | ExitDiagBlock(); |
| 557 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 558 | return; |
| 559 | } |
| 560 | |
| 561 | assert(Info.hasSourceManager() && LangOpts && |
| 562 | "Unexpected diagnostic with valid location outside of a source file"); |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 563 | SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 564 | Renderer.emitDiagnostic(Info.getLocation(), DiagLevel, |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 565 | State->diagBuf.str(), |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 566 | Info.getRanges(), |
| 567 | llvm::makeArrayRef(Info.getFixItHints(), |
| 568 | Info.getNumFixItHints()), |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 569 | &Info.getSourceManager(), |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 570 | &Info); |
| 571 | } |
| 572 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 573 | void SDiagsWriter::EmitDiagnosticMessage(SourceLocation Loc, |
| 574 | PresumedLoc PLoc, |
| 575 | DiagnosticsEngine::Level Level, |
| 576 | StringRef Message, |
| 577 | const SourceManager *SM, |
| 578 | DiagOrStoredDiag D) { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 579 | llvm::BitstreamWriter &Stream = State->Stream; |
| 580 | RecordData &Record = State->Record; |
| 581 | AbbreviationMap &Abbrevs = State->Abbrevs; |
| 582 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 583 | // Emit the RECORD_DIAG record. |
| 584 | Record.clear(); |
| 585 | Record.push_back(RECORD_DIAG); |
| 586 | Record.push_back(Level); |
| 587 | AddLocToRecord(Loc, SM, PLoc, Record); |
| 588 | |
| 589 | if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) { |
| 590 | // Emit the category string lazily and get the category ID. |
| 591 | unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID()); |
| 592 | Record.push_back(getEmitCategory(DiagID)); |
| 593 | // Emit the diagnostic flag string lazily and get the mapped ID. |
| 594 | Record.push_back(getEmitDiagnosticFlag(Level, Info->getID())); |
| 595 | } else { |
| 596 | Record.push_back(getEmitCategory()); |
| 597 | Record.push_back(getEmitDiagnosticFlag(Level)); |
| 598 | } |
| 599 | |
| 600 | Record.push_back(Message.size()); |
| 601 | Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message); |
| 602 | } |
| 603 | |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 604 | void |
| 605 | SDiagsRenderer::emitDiagnosticMessage(SourceLocation Loc, |
| 606 | PresumedLoc PLoc, |
| 607 | DiagnosticsEngine::Level Level, |
| 608 | StringRef Message, |
| 609 | ArrayRef<clang::CharSourceRange> Ranges, |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 610 | const SourceManager *SM, |
Ted Kremenek | 8be51ea | 2012-02-14 02:46:00 +0000 | [diff] [blame] | 611 | DiagOrStoredDiag D) { |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 612 | Writer.EmitDiagnosticMessage(Loc, PLoc, Level, Message, SM, D); |
| 613 | } |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 614 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 615 | void SDiagsWriter::EnterDiagBlock() { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 616 | State->Stream.EnterSubblock(BLOCK_DIAG, 4); |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 617 | } |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 618 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 619 | void SDiagsWriter::ExitDiagBlock() { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 620 | State->Stream.ExitBlock(); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 621 | } |
| 622 | |
Ted Kremenek | 8be51ea | 2012-02-14 02:46:00 +0000 | [diff] [blame] | 623 | void SDiagsRenderer::beginDiagnostic(DiagOrStoredDiag D, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 624 | DiagnosticsEngine::Level Level) { |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 625 | if (Level == DiagnosticsEngine::Note) |
| 626 | Writer.EnterDiagBlock(); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 627 | } |
| 628 | |
Ted Kremenek | 8be51ea | 2012-02-14 02:46:00 +0000 | [diff] [blame] | 629 | void SDiagsRenderer::endDiagnostic(DiagOrStoredDiag D, |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 630 | DiagnosticsEngine::Level Level) { |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 631 | // Only end note diagnostics here, because we can't be sure when we've seen |
| 632 | // the last note associated with a non-note diagnostic. |
| 633 | if (Level == DiagnosticsEngine::Note) |
| 634 | Writer.ExitDiagBlock(); |
| 635 | } |
| 636 | |
| 637 | void SDiagsWriter::EmitCodeContext(SmallVectorImpl<CharSourceRange> &Ranges, |
| 638 | ArrayRef<FixItHint> Hints, |
| 639 | const SourceManager &SM) { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 640 | llvm::BitstreamWriter &Stream = State->Stream; |
| 641 | RecordData &Record = State->Record; |
| 642 | AbbreviationMap &Abbrevs = State->Abbrevs; |
| 643 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 644 | // Emit Source Ranges. |
| 645 | for (ArrayRef<CharSourceRange>::iterator I = Ranges.begin(), E = Ranges.end(); |
| 646 | I != E; ++I) |
| 647 | if (I->isValid()) |
| 648 | EmitCharSourceRange(*I, SM); |
| 649 | |
| 650 | // Emit FixIts. |
| 651 | for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end(); |
| 652 | I != E; ++I) { |
| 653 | const FixItHint &Fix = *I; |
| 654 | if (Fix.isNull()) |
| 655 | continue; |
| 656 | Record.clear(); |
| 657 | Record.push_back(RECORD_FIXIT); |
| 658 | AddCharSourceRangeToRecord(Fix.RemoveRange, Record, SM); |
| 659 | Record.push_back(Fix.CodeToInsert.size()); |
| 660 | Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record, |
| 661 | Fix.CodeToInsert); |
| 662 | } |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 663 | } |
| 664 | |
| 665 | void SDiagsRenderer::emitCodeContext(SourceLocation Loc, |
| 666 | DiagnosticsEngine::Level Level, |
| 667 | SmallVectorImpl<CharSourceRange> &Ranges, |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 668 | ArrayRef<FixItHint> Hints, |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 669 | const SourceManager &SM) { |
| 670 | Writer.EmitCodeContext(Ranges, Hints, SM); |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 671 | } |
| 672 | |
Argyrios Kyrtzidis | 16afdf7 | 2012-05-10 05:03:45 +0000 | [diff] [blame] | 673 | void SDiagsRenderer::emitNote(SourceLocation Loc, StringRef Message, |
| 674 | const SourceManager *SM) { |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 675 | Writer.EnterDiagBlock(); |
| 676 | PresumedLoc PLoc = SM ? SM->getPresumedLoc(Loc) : PresumedLoc(); |
| 677 | Writer.EmitDiagnosticMessage(Loc, PLoc, DiagnosticsEngine::Note, |
| 678 | Message, SM, DiagOrStoredDiag()); |
| 679 | Writer.ExitDiagBlock(); |
Ted Kremenek | 2a76410 | 2011-12-17 05:26:11 +0000 | [diff] [blame] | 680 | } |
| 681 | |
Argyrios Kyrtzidis | 29f2787 | 2011-12-07 05:52:12 +0000 | [diff] [blame] | 682 | void SDiagsWriter::finish() { |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 683 | // The original instance is responsible for writing the file. |
| 684 | if (!OriginalInstance) |
| 685 | return; |
| 686 | |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 687 | // Finish off any diagnostic we were in the process of emitting. |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 688 | if (State->EmittedAnyDiagBlocks) |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 689 | ExitDiagBlock(); |
Ted Kremenek | 0d34e6e | 2011-11-05 00:10:11 +0000 | [diff] [blame] | 690 | |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 691 | // Write the generated bitstream to "Out". |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 692 | State->OS->write((char *)&State->Buffer.front(), State->Buffer.size()); |
| 693 | State->OS->flush(); |
Richard Smith | db309ae | 2012-08-21 03:11:53 +0000 | [diff] [blame] | 694 | |
Douglas Gregor | 14afab3 | 2012-11-30 23:32:31 +0000 | [diff] [blame] | 695 | State->OS.reset(0); |
Ted Kremenek | 7800212 | 2011-10-29 00:12:39 +0000 | [diff] [blame] | 696 | } |