1 //===--- PartialDiagnostic.h - Diagnostic "closures" ------------*- C++ -*-===// 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 /// \file 11 /// \brief Implements a partial diagnostic that can be emitted anwyhere 12 /// in a DiagnosticBuilder stream. 13 /// 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_CLANG_PARTIALDIAGNOSTIC_H 17 #define LLVM_CLANG_PARTIALDIAGNOSTIC_H 18 19 #include "clang/Basic/Diagnostic.h" 20 #include "clang/Basic/SourceLocation.h" 21 #include "llvm/ADT/STLExtras.h" 22 #include "llvm/Support/DataTypes.h" 23 #include <cassert> 24 25 namespace clang { 26 27 class PartialDiagnostic { 28 public: 29 enum { 30 // The MaxArguments and MaxFixItHints member enum values from 31 // DiagnosticsEngine are private but DiagnosticsEngine declares 32 // PartialDiagnostic a friend. These enum values are redeclared 33 // here so that the nested Storage class below can access them. 34 MaxArguments = DiagnosticsEngine::MaxArguments 35 }; 36 37 struct Storage { 38 Storage() : NumDiagArgs(0), NumDiagRanges(0) { } 39 40 enum { 41 /// \brief The maximum number of arguments we can hold. We 42 /// currently only support up to 10 arguments (%0-%9). 43 /// 44 /// A single diagnostic with more than that almost certainly has to 45 /// be simplified anyway. 46 MaxArguments = PartialDiagnostic::MaxArguments 47 }; 48 49 /// \brief The number of entries in Arguments. 50 unsigned char NumDiagArgs; 51 52 /// \brief This is the number of ranges in the DiagRanges array. 53 unsigned char NumDiagRanges; 54 55 /// \brief Specifies for each argument whether it is in DiagArgumentsStr 56 /// or in DiagArguments. 57 unsigned char DiagArgumentsKind[MaxArguments]; 58 59 /// \brief The values for the various substitution positions. 60 /// 61 /// This is used when the argument is not an std::string. The specific value 62 /// is mangled into an intptr_t and the interpretation depends on exactly 63 /// what sort of argument kind it is. 64 intptr_t DiagArgumentsVal[MaxArguments]; 65 66 /// \brief The values for the various substitution positions that have 67 /// string arguments. 68 std::string DiagArgumentsStr[MaxArguments]; 69 70 /// \brief The list of ranges added to this diagnostic. 71 /// 72 /// It currently only support 10 ranges, could easily be extended if needed. 73 CharSourceRange DiagRanges[10]; 74 75 /// \brief If valid, provides a hint with some code to insert, remove, or 76 /// modify at a particular position. 77 SmallVector<FixItHint, 6> FixItHints; 78 }; 79 80 /// \brief An allocator for Storage objects, which uses a small cache to 81 /// objects, used to reduce malloc()/free() traffic for partial diagnostics. 82 class StorageAllocator { 83 static const unsigned NumCached = 16; 84 Storage Cached[NumCached]; 85 Storage *FreeList[NumCached]; 86 unsigned NumFreeListEntries; 87 88 public: 89 StorageAllocator(); 90 ~StorageAllocator(); 91 92 /// \brief Allocate new storage. 93 Storage *Allocate() { 94 if (NumFreeListEntries == 0) 95 return new Storage; 96 97 Storage *Result = FreeList[--NumFreeListEntries]; 98 Result->NumDiagArgs = 0; 99 Result->NumDiagRanges = 0; 100 Result->FixItHints.clear(); 101 return Result; 102 } 103 104 /// \brief Free the given storage object. 105 void Deallocate(Storage *S) { 106 if (S >= Cached && S <= Cached + NumCached) { 107 FreeList[NumFreeListEntries++] = S; 108 return; 109 } 110 111 delete S; 112 } 113 }; 114 115 private: 116 // NOTE: Sema assumes that PartialDiagnostic is location-invariant 117 // in the sense that its bits can be safely memcpy'ed and destructed 118 // in the new location. 119 120 /// \brief The diagnostic ID. 121 mutable unsigned DiagID; 122 123 /// \brief Storage for args and ranges. 124 mutable Storage *DiagStorage; 125 126 /// \brief Allocator used to allocate storage for this diagnostic. 127 StorageAllocator *Allocator; 128 129 /// \brief Retrieve storage for this particular diagnostic. 130 Storage *getStorage() const { 131 if (DiagStorage) 132 return DiagStorage; 133 134 if (Allocator) 135 DiagStorage = Allocator->Allocate(); 136 else { 137 assert(Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0))); 138 DiagStorage = new Storage; 139 } 140 return DiagStorage; 141 } 142 143 void freeStorage() { 144 if (!DiagStorage) 145 return; 146 147 // The hot path for PartialDiagnostic is when we just used it to wrap an ID 148 // (typically so we have the flexibility of passing a more complex 149 // diagnostic into the callee, but that does not commonly occur). 150 // 151 // Split this out into a slow function for silly compilers (*cough*) which 152 // can't do decent partial inlining. 153 freeStorageSlow(); 154 } 155 156 void freeStorageSlow() { 157 if (Allocator) 158 Allocator->Deallocate(DiagStorage); 159 else if (Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0))) 160 delete DiagStorage; 161 DiagStorage = 0; 162 } 163 164 void AddSourceRange(const CharSourceRange &R) const { 165 if (!DiagStorage) 166 DiagStorage = getStorage(); 167 168 assert(DiagStorage->NumDiagRanges < 169 llvm::array_lengthof(DiagStorage->DiagRanges) && 170 "Too many arguments to diagnostic!"); 171 DiagStorage->DiagRanges[DiagStorage->NumDiagRanges++] = R; 172 } 173 174 void AddFixItHint(const FixItHint &Hint) const { 175 if (Hint.isNull()) 176 return; 177 178 if (!DiagStorage) 179 DiagStorage = getStorage(); 180 181 DiagStorage->FixItHints.push_back(Hint); 182 } 183 184 public: 185 struct NullDiagnostic {}; 186 /// \brief Create a null partial diagnostic, which cannot carry a payload, 187 /// and only exists to be swapped with a real partial diagnostic. 188 PartialDiagnostic(NullDiagnostic) 189 : DiagID(0), DiagStorage(0), Allocator(0) { } 190 191 PartialDiagnostic(unsigned DiagID, StorageAllocator &Allocator) 192 : DiagID(DiagID), DiagStorage(0), Allocator(&Allocator) { } 193 194 PartialDiagnostic(const PartialDiagnostic &Other) 195 : DiagID(Other.DiagID), DiagStorage(0), Allocator(Other.Allocator) 196 { 197 if (Other.DiagStorage) { 198 DiagStorage = getStorage(); 199 *DiagStorage = *Other.DiagStorage; 200 } 201 } 202 203 PartialDiagnostic(const PartialDiagnostic &Other, Storage *DiagStorage) 204 : DiagID(Other.DiagID), DiagStorage(DiagStorage), 205 Allocator(reinterpret_cast<StorageAllocator *>(~uintptr_t(0))) 206 { 207 if (Other.DiagStorage) 208 *this->DiagStorage = *Other.DiagStorage; 209 } 210 211 PartialDiagnostic(const Diagnostic &Other, StorageAllocator &Allocator) 212 : DiagID(Other.getID()), DiagStorage(0), Allocator(&Allocator) 213 { 214 // Copy arguments. 215 for (unsigned I = 0, N = Other.getNumArgs(); I != N; ++I) { 216 if (Other.getArgKind(I) == DiagnosticsEngine::ak_std_string) 217 AddString(Other.getArgStdStr(I)); 218 else 219 AddTaggedVal(Other.getRawArg(I), Other.getArgKind(I)); 220 } 221 222 // Copy source ranges. 223 for (unsigned I = 0, N = Other.getNumRanges(); I != N; ++I) 224 AddSourceRange(Other.getRange(I)); 225 226 // Copy fix-its. 227 for (unsigned I = 0, N = Other.getNumFixItHints(); I != N; ++I) 228 AddFixItHint(Other.getFixItHint(I)); 229 } 230 231 PartialDiagnostic &operator=(const PartialDiagnostic &Other) { 232 DiagID = Other.DiagID; 233 if (Other.DiagStorage) { 234 if (!DiagStorage) 235 DiagStorage = getStorage(); 236 237 *DiagStorage = *Other.DiagStorage; 238 } else { 239 freeStorage(); 240 } 241 242 return *this; 243 } 244 245 ~PartialDiagnostic() { 246 freeStorage(); 247 } 248 249 void swap(PartialDiagnostic &PD) { 250 std::swap(DiagID, PD.DiagID); 251 std::swap(DiagStorage, PD.DiagStorage); 252 std::swap(Allocator, PD.Allocator); 253 } 254 255 unsigned getDiagID() const { return DiagID; } 256 257 void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const { 258 if (!DiagStorage) 259 DiagStorage = getStorage(); 260 261 assert(DiagStorage->NumDiagArgs < Storage::MaxArguments && 262 "Too many arguments to diagnostic!"); 263 DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = Kind; 264 DiagStorage->DiagArgumentsVal[DiagStorage->NumDiagArgs++] = V; 265 } 266 267 void AddString(StringRef V) const { 268 if (!DiagStorage) 269 DiagStorage = getStorage(); 270 271 assert(DiagStorage->NumDiagArgs < Storage::MaxArguments && 272 "Too many arguments to diagnostic!"); 273 DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] 274 = DiagnosticsEngine::ak_std_string; 275 DiagStorage->DiagArgumentsStr[DiagStorage->NumDiagArgs++] = V; 276 } 277 278 void Emit(const DiagnosticBuilder &DB) const { 279 if (!DiagStorage) 280 return; 281 282 // Add all arguments. 283 for (unsigned i = 0, e = DiagStorage->NumDiagArgs; i != e; ++i) { 284 if ((DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i] 285 == DiagnosticsEngine::ak_std_string) 286 DB.AddString(DiagStorage->DiagArgumentsStr[i]); 287 else 288 DB.AddTaggedVal(DiagStorage->DiagArgumentsVal[i], 289 (DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i]); 290 } 291 292 // Add all ranges. 293 for (unsigned i = 0, e = DiagStorage->NumDiagRanges; i != e; ++i) 294 DB.AddSourceRange(DiagStorage->DiagRanges[i]); 295 296 // Add all fix-its. 297 for (unsigned i = 0, e = DiagStorage->FixItHints.size(); i != e; ++i) 298 DB.AddFixItHint(DiagStorage->FixItHints[i]); 299 } 300 301 void EmitToString(DiagnosticsEngine &Diags, 302 llvm::SmallVectorImpl<char> &Buf) const { 303 // FIXME: It should be possible to render a diagnostic to a string without 304 // messing with the state of the diagnostics engine. 305 DiagnosticBuilder DB(Diags.Report(getDiagID())); 306 Emit(DB); 307 DB.FlushCounts(); 308 Diagnostic(&Diags).FormatDiagnostic(Buf); 309 DB.Clear(); 310 Diags.Clear(); 311 } 312 313 /// \brief Clear out this partial diagnostic, giving it a new diagnostic ID 314 /// and removing all of its arguments, ranges, and fix-it hints. 315 void Reset(unsigned DiagID = 0) { 316 this->DiagID = DiagID; 317 freeStorage(); 318 } 319 320 bool hasStorage() const { return DiagStorage != 0; } 321 322 friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 323 unsigned I) { 324 PD.AddTaggedVal(I, DiagnosticsEngine::ak_uint); 325 return PD; 326 } 327 328 friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 329 int I) { 330 PD.AddTaggedVal(I, DiagnosticsEngine::ak_sint); 331 return PD; 332 } 333 334 friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 335 const char *S) { 336 PD.AddTaggedVal(reinterpret_cast<intptr_t>(S), 337 DiagnosticsEngine::ak_c_string); 338 return PD; 339 } 340 341 friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 342 StringRef S) { 343 344 PD.AddString(S); 345 return PD; 346 } 347 348 friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 349 const SourceRange &R) { 350 PD.AddSourceRange(CharSourceRange::getTokenRange(R)); 351 return PD; 352 } 353 354 friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 355 const CharSourceRange &R) { 356 PD.AddSourceRange(R); 357 return PD; 358 } 359 360 friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 361 const FixItHint &Hint) { 362 PD.AddFixItHint(Hint); 363 return PD; 364 } 365 366 }; 367 368 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, 369 const PartialDiagnostic &PD) { 370 PD.Emit(DB); 371 return DB; 372 } 373 374 /// \brief A partial diagnostic along with the source location where this 375 /// diagnostic occurs. 376 typedef std::pair<SourceLocation, PartialDiagnostic> PartialDiagnosticAt; 377 378 } // end namespace clang 379 #endif 380
