1 //===--- DiagnosticRenderer.cpp - Diagnostic Pretty-Printing --------------===// 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/DiagnosticRenderer.h" 11 #include "clang/Basic/FileManager.h" 12 #include "clang/Basic/SourceManager.h" 13 #include "clang/Frontend/DiagnosticOptions.h" 14 #include "clang/Lex/Lexer.h" 15 #include "clang/Edit/EditedSource.h" 16 #include "clang/Edit/Commit.h" 17 #include "clang/Edit/EditsReceiver.h" 18 #include "llvm/Support/MemoryBuffer.h" 19 #include "llvm/Support/raw_ostream.h" 20 #include "llvm/Support/ErrorHandling.h" 21 #include "llvm/ADT/SmallString.h" 22 #include <algorithm> 23 using namespace clang; 24 25 /// Look through spelling locations for a macro argument expansion, and 26 /// if found skip to it so that we can trace the argument rather than the macros 27 /// in which that argument is used. If no macro argument expansion is found, 28 /// don't skip anything and return the starting location. 29 static SourceLocation skipToMacroArgExpansion(const SourceManager &SM, 30 SourceLocation StartLoc) { 31 for (SourceLocation L = StartLoc; L.isMacroID(); 32 L = SM.getImmediateSpellingLoc(L)) { 33 if (SM.isMacroArgExpansion(L)) 34 return L; 35 } 36 37 // Otherwise just return initial location, there's nothing to skip. 38 return StartLoc; 39 } 40 41 /// Gets the location of the immediate macro caller, one level up the stack 42 /// toward the initial macro typed into the source. 43 static SourceLocation getImmediateMacroCallerLoc(const SourceManager &SM, 44 SourceLocation Loc) { 45 if (!Loc.isMacroID()) return Loc; 46 47 // When we have the location of (part of) an expanded parameter, its spelling 48 // location points to the argument as typed into the macro call, and 49 // therefore is used to locate the macro caller. 50 if (SM.isMacroArgExpansion(Loc)) 51 return SM.getImmediateSpellingLoc(Loc); 52 53 // Otherwise, the caller of the macro is located where this macro is 54 // expanded (while the spelling is part of the macro definition). 55 return SM.getImmediateExpansionRange(Loc).first; 56 } 57 58 /// Gets the location of the immediate macro callee, one level down the stack 59 /// toward the leaf macro. 60 static SourceLocation getImmediateMacroCalleeLoc(const SourceManager &SM, 61 SourceLocation Loc) { 62 if (!Loc.isMacroID()) return Loc; 63 64 // When we have the location of (part of) an expanded parameter, its 65 // expansion location points to the unexpanded paramater reference within 66 // the macro definition (or callee). 67 if (SM.isMacroArgExpansion(Loc)) 68 return SM.getImmediateExpansionRange(Loc).first; 69 70 // Otherwise, the callee of the macro is located where this location was 71 // spelled inside the macro definition. 72 return SM.getImmediateSpellingLoc(Loc); 73 } 74 75 /// \brief Retrieve the name of the immediate macro expansion. 76 /// 77 /// This routine starts from a source location, and finds the name of the macro 78 /// responsible for its immediate expansion. It looks through any intervening 79 /// macro argument expansions to compute this. It returns a StringRef which 80 /// refers to the SourceManager-owned buffer of the source where that macro 81 /// name is spelled. Thus, the result shouldn't out-live that SourceManager. 82 /// 83 /// This differs from Lexer::getImmediateMacroName in that any macro argument 84 /// location will result in the topmost function macro that accepted it. 85 /// e.g. 86 /// \code 87 /// MAC1( MAC2(foo) ) 88 /// \endcode 89 /// for location of 'foo' token, this function will return "MAC1" while 90 /// Lexer::getImmediateMacroName will return "MAC2". 91 static StringRef getImmediateMacroName(SourceLocation Loc, 92 const SourceManager &SM, 93 const LangOptions &LangOpts) { 94 assert(Loc.isMacroID() && "Only reasonble to call this on macros"); 95 // Walk past macro argument expanions. 96 while (SM.isMacroArgExpansion(Loc)) 97 Loc = SM.getImmediateExpansionRange(Loc).first; 98 99 // Find the spelling location of the start of the non-argument expansion 100 // range. This is where the macro name was spelled in order to begin 101 // expanding this macro. 102 Loc = SM.getSpellingLoc(SM.getImmediateExpansionRange(Loc).first); 103 104 // Dig out the buffer where the macro name was spelled and the extents of the 105 // name so that we can render it into the expansion note. 106 std::pair<FileID, unsigned> ExpansionInfo = SM.getDecomposedLoc(Loc); 107 unsigned MacroTokenLength = Lexer::MeasureTokenLength(Loc, SM, LangOpts); 108 StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first); 109 return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength); 110 } 111 112 /// Get the presumed location of a diagnostic message. This computes the 113 /// presumed location for the top of any macro backtrace when present. 114 static PresumedLoc getDiagnosticPresumedLoc(const SourceManager &SM, 115 SourceLocation Loc) { 116 // This is a condensed form of the algorithm used by emitCaretDiagnostic to 117 // walk to the top of the macro call stack. 118 while (Loc.isMacroID()) { 119 Loc = skipToMacroArgExpansion(SM, Loc); 120 Loc = getImmediateMacroCallerLoc(SM, Loc); 121 } 122 123 return SM.getPresumedLoc(Loc); 124 } 125 126 DiagnosticRenderer::DiagnosticRenderer(const SourceManager &SM, 127 const LangOptions &LangOpts, 128 const DiagnosticOptions &DiagOpts) 129 : SM(SM), LangOpts(LangOpts), DiagOpts(DiagOpts), LastLevel() {} 130 131 DiagnosticRenderer::~DiagnosticRenderer() {} 132 133 namespace { 134 135 class FixitReceiver : public edit::EditsReceiver { 136 SmallVectorImpl<FixItHint> &MergedFixits; 137 138 public: 139 FixitReceiver(SmallVectorImpl<FixItHint> &MergedFixits) 140 : MergedFixits(MergedFixits) { } 141 virtual void insert(SourceLocation loc, StringRef text) { 142 MergedFixits.push_back(FixItHint::CreateInsertion(loc, text)); 143 } 144 virtual void replace(CharSourceRange range, StringRef text) { 145 MergedFixits.push_back(FixItHint::CreateReplacement(range, text)); 146 } 147 }; 148 149 } 150 151 static void mergeFixits(ArrayRef<FixItHint> FixItHints, 152 const SourceManager &SM, const LangOptions &LangOpts, 153 SmallVectorImpl<FixItHint> &MergedFixits) { 154 edit::Commit commit(SM, LangOpts); 155 for (ArrayRef<FixItHint>::const_iterator 156 I = FixItHints.begin(), E = FixItHints.end(); I != E; ++I) { 157 const FixItHint &Hint = *I; 158 if (Hint.CodeToInsert.empty()) { 159 if (Hint.InsertFromRange.isValid()) 160 commit.insertFromRange(Hint.RemoveRange.getBegin(), 161 Hint.InsertFromRange, /*afterToken=*/false, 162 Hint.BeforePreviousInsertions); 163 else 164 commit.remove(Hint.RemoveRange); 165 } else { 166 if (Hint.RemoveRange.isTokenRange() || 167 Hint.RemoveRange.getBegin() != Hint.RemoveRange.getEnd()) 168 commit.replace(Hint.RemoveRange, Hint.CodeToInsert); 169 else 170 commit.insert(Hint.RemoveRange.getBegin(), Hint.CodeToInsert, 171 /*afterToken=*/false, Hint.BeforePreviousInsertions); 172 } 173 } 174 175 edit::EditedSource Editor(SM, LangOpts); 176 if (Editor.commit(commit)) { 177 FixitReceiver Rec(MergedFixits); 178 Editor.applyRewrites(Rec); 179 } 180 } 181 182 void DiagnosticRenderer::emitDiagnostic(SourceLocation Loc, 183 DiagnosticsEngine::Level Level, 184 StringRef Message, 185 ArrayRef<CharSourceRange> Ranges, 186 ArrayRef<FixItHint> FixItHints, 187 DiagOrStoredDiag D) { 188 189 beginDiagnostic(D, Level); 190 191 PresumedLoc PLoc = getDiagnosticPresumedLoc(SM, Loc); 192 193 // First, if this diagnostic is not in the main file, print out the 194 // "included from" lines. 195 emitIncludeStack(PLoc.getIncludeLoc(), Level); 196 197 // Next, emit the actual diagnostic message. 198 emitDiagnosticMessage(Loc, PLoc, Level, Message, Ranges, D); 199 200 // Only recurse if we have a valid location. 201 if (Loc.isValid()) { 202 // Get the ranges into a local array we can hack on. 203 SmallVector<CharSourceRange, 20> MutableRanges(Ranges.begin(), 204 Ranges.end()); 205 206 llvm::SmallVector<FixItHint, 8> MergedFixits; 207 if (!FixItHints.empty()) { 208 mergeFixits(FixItHints, SM, LangOpts, MergedFixits); 209 FixItHints = MergedFixits; 210 } 211 212 for (ArrayRef<FixItHint>::const_iterator I = FixItHints.begin(), 213 E = FixItHints.end(); 214 I != E; ++I) 215 if (I->RemoveRange.isValid()) 216 MutableRanges.push_back(I->RemoveRange); 217 218 unsigned MacroDepth = 0; 219 emitMacroExpansionsAndCarets(Loc, Level, MutableRanges, FixItHints, 220 MacroDepth); 221 } 222 223 LastLoc = Loc; 224 LastLevel = Level; 225 226 endDiagnostic(D, Level); 227 } 228 229 230 void DiagnosticRenderer::emitStoredDiagnostic(StoredDiagnostic &Diag) { 231 emitDiagnostic(Diag.getLocation(), Diag.getLevel(), Diag.getMessage(), 232 Diag.getRanges(), Diag.getFixIts(), 233 &Diag); 234 } 235 236 /// \brief Prints an include stack when appropriate for a particular 237 /// diagnostic level and location. 238 /// 239 /// This routine handles all the logic of suppressing particular include 240 /// stacks (such as those for notes) and duplicate include stacks when 241 /// repeated warnings occur within the same file. It also handles the logic 242 /// of customizing the formatting and display of the include stack. 243 /// 244 /// \param Level The diagnostic level of the message this stack pertains to. 245 /// \param Loc The include location of the current file (not the diagnostic 246 /// location). 247 void DiagnosticRenderer::emitIncludeStack(SourceLocation Loc, 248 DiagnosticsEngine::Level Level) { 249 // Skip redundant include stacks altogether. 250 if (LastIncludeLoc == Loc) 251 return; 252 LastIncludeLoc = Loc; 253 254 if (!DiagOpts.ShowNoteIncludeStack && Level == DiagnosticsEngine::Note) 255 return; 256 257 emitIncludeStackRecursively(Loc); 258 } 259 260 /// \brief Helper to recursivly walk up the include stack and print each layer 261 /// on the way back down. 262 void DiagnosticRenderer::emitIncludeStackRecursively(SourceLocation Loc) { 263 if (Loc.isInvalid()) 264 return; 265 266 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 267 if (PLoc.isInvalid()) 268 return; 269 270 // Emit the other include frames first. 271 emitIncludeStackRecursively(PLoc.getIncludeLoc()); 272 273 // Emit the inclusion text/note. 274 emitIncludeLocation(Loc, PLoc); 275 } 276 277 /// \brief Recursively emit notes for each macro expansion and caret 278 /// diagnostics where appropriate. 279 /// 280 /// Walks up the macro expansion stack printing expansion notes, the code 281 /// snippet, caret, underlines and FixItHint display as appropriate at each 282 /// level. 283 /// 284 /// \param Loc The location for this caret. 285 /// \param Level The diagnostic level currently being emitted. 286 /// \param Ranges The underlined ranges for this code snippet. 287 /// \param Hints The FixIt hints active for this diagnostic. 288 /// \param MacroSkipEnd The depth to stop skipping macro expansions. 289 /// \param OnMacroInst The current depth of the macro expansion stack. 290 void DiagnosticRenderer::emitMacroExpansionsAndCarets( 291 SourceLocation Loc, 292 DiagnosticsEngine::Level Level, 293 SmallVectorImpl<CharSourceRange>& Ranges, 294 ArrayRef<FixItHint> Hints, 295 unsigned &MacroDepth, 296 unsigned OnMacroInst) 297 { 298 assert(!Loc.isInvalid() && "must have a valid source location here"); 299 300 // If this is a file source location, directly emit the source snippet and 301 // caret line. Also record the macro depth reached. 302 if (Loc.isFileID()) { 303 assert(MacroDepth == 0 && "We shouldn't hit a leaf node twice!"); 304 MacroDepth = OnMacroInst; 305 emitCodeContext(Loc, Level, Ranges, Hints); 306 return; 307 } 308 // Otherwise recurse through each macro expansion layer. 309 310 // When processing macros, skip over the expansions leading up to 311 // a macro argument, and trace the argument's expansion stack instead. 312 Loc = skipToMacroArgExpansion(SM, Loc); 313 314 SourceLocation OneLevelUp = getImmediateMacroCallerLoc(SM, Loc); 315 316 // FIXME: Map ranges? 317 emitMacroExpansionsAndCarets(OneLevelUp, Level, Ranges, Hints, MacroDepth, 318 OnMacroInst + 1); 319 320 // Save the original location so we can find the spelling of the macro call. 321 SourceLocation MacroLoc = Loc; 322 323 // Map the location. 324 Loc = getImmediateMacroCalleeLoc(SM, Loc); 325 326 unsigned MacroSkipStart = 0, MacroSkipEnd = 0; 327 if (MacroDepth > DiagOpts.MacroBacktraceLimit && 328 DiagOpts.MacroBacktraceLimit != 0) { 329 MacroSkipStart = DiagOpts.MacroBacktraceLimit / 2 + 330 DiagOpts.MacroBacktraceLimit % 2; 331 MacroSkipEnd = MacroDepth - DiagOpts.MacroBacktraceLimit / 2; 332 } 333 334 // Whether to suppress printing this macro expansion. 335 bool Suppressed = (OnMacroInst >= MacroSkipStart && 336 OnMacroInst < MacroSkipEnd); 337 338 // Map the ranges. 339 for (SmallVectorImpl<CharSourceRange>::iterator I = Ranges.begin(), 340 E = Ranges.end(); 341 I != E; ++I) { 342 SourceLocation Start = I->getBegin(), End = I->getEnd(); 343 if (Start.isMacroID()) 344 I->setBegin(getImmediateMacroCalleeLoc(SM, Start)); 345 if (End.isMacroID()) 346 I->setEnd(getImmediateMacroCalleeLoc(SM, End)); 347 } 348 349 if (Suppressed) { 350 // Tell the user that we've skipped contexts. 351 if (OnMacroInst == MacroSkipStart) { 352 SmallString<200> MessageStorage; 353 llvm::raw_svector_ostream Message(MessageStorage); 354 Message << "(skipping " << (MacroSkipEnd - MacroSkipStart) 355 << " expansions in backtrace; use -fmacro-backtrace-limit=0 to " 356 "see all)"; 357 emitBasicNote(Message.str()); 358 } 359 return; 360 } 361 362 SmallString<100> MessageStorage; 363 llvm::raw_svector_ostream Message(MessageStorage); 364 Message << "expanded from macro '" 365 << getImmediateMacroName(MacroLoc, SM, LangOpts) << "'"; 366 emitDiagnostic(SM.getSpellingLoc(Loc), DiagnosticsEngine::Note, 367 Message.str(), 368 Ranges, ArrayRef<FixItHint>()); 369 } 370 371 DiagnosticNoteRenderer::~DiagnosticNoteRenderer() {} 372 373 void DiagnosticNoteRenderer::emitIncludeLocation(SourceLocation Loc, 374 PresumedLoc PLoc) { 375 // Generate a note indicating the include location. 376 SmallString<200> MessageStorage; 377 llvm::raw_svector_ostream Message(MessageStorage); 378 Message << "in file included from " << PLoc.getFilename() << ':' 379 << PLoc.getLine() << ":"; 380 emitNote(Loc, Message.str()); 381 } 382 383 void DiagnosticNoteRenderer::emitBasicNote(StringRef Message) { 384 emitNote(SourceLocation(), Message); 385 } 386 387