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