1 //==--- DiagnosticGroups.td - Diagnostic Group Definitions ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 def ImplicitFunctionDeclare : DiagGroup<"implicit-function-declaration">;
11 def ImplicitInt : DiagGroup<"implicit-int">;
13 // Aggregation warning settings.
14 def Implicit : DiagGroup<"implicit", [
15 ImplicitFunctionDeclare,
19 // Empty DiagGroups are recognized by clang but ignored.
20 def : DiagGroup<"abi">;
21 def AbsoluteValue : DiagGroup<"absolute-value">;
22 def AddressOfTemporary : DiagGroup<"address-of-temporary">;
23 def : DiagGroup<"aggregate-return">;
24 def GNUAlignofExpression : DiagGroup<"gnu-alignof-expression">;
25 def AmbigMemberTemplate : DiagGroup<"ambiguous-member-template">;
26 def GNUAnonymousStruct : DiagGroup<"gnu-anonymous-struct">;
27 def GNUAutoType : DiagGroup<"gnu-auto-type">;
28 def ArrayBounds : DiagGroup<"array-bounds">;
29 def ArrayBoundsPointerArithmetic : DiagGroup<"array-bounds-pointer-arithmetic">;
30 def Availability : DiagGroup<"availability">;
31 def Section : DiagGroup<"section">;
32 def AutoImport : DiagGroup<"auto-import">;
33 def CXX14BinaryLiteral : DiagGroup<"c++14-binary-literal">;
34 def GNUBinaryLiteral : DiagGroup<"gnu-binary-literal">;
35 def GNUCompoundLiteralInitializer : DiagGroup<"gnu-compound-literal-initializer">;
36 def BitFieldConstantConversion : DiagGroup<"bitfield-constant-conversion">;
37 def BitFieldWidth : DiagGroup<"bitfield-width">;
38 def ConstantConversion :
39 DiagGroup<"constant-conversion", [ BitFieldConstantConversion ] >;
40 def LiteralConversion : DiagGroup<"literal-conversion">;
41 def StringConversion : DiagGroup<"string-conversion">;
42 def SignConversion : DiagGroup<"sign-conversion">;
43 def PointerBoolConversion : DiagGroup<"pointer-bool-conversion">;
44 def UndefinedBoolConversion : DiagGroup<"undefined-bool-conversion">;
45 def BoolConversion : DiagGroup<"bool-conversion", [PointerBoolConversion,
46 UndefinedBoolConversion]>;
47 def IntConversion : DiagGroup<"int-conversion">;
48 def EnumConversion : DiagGroup<"enum-conversion">;
50 def FloatOverflowConversion : DiagGroup<"float-overflow-conversion">;
51 def FloatZeroConversion : DiagGroup<"float-zero-conversion">;
53 DiagGroup<"float-conversion", [FloatOverflowConversion,
54 FloatZeroConversion]>;
56 def DoublePromotion : DiagGroup<"double-promotion">;
57 def EnumTooLarge : DiagGroup<"enum-too-large">;
58 def UnsupportedNan : DiagGroup<"unsupported-nan">;
59 def UnsupportedCB : DiagGroup<"unsupported-cb">;
60 def NonLiteralNullConversion : DiagGroup<"non-literal-null-conversion">;
61 def NullConversion : DiagGroup<"null-conversion">;
62 def ImplicitConversionFloatingPointToBool :
63 DiagGroup<"implicit-conversion-floating-point-to-bool">;
64 def ObjCLiteralConversion : DiagGroup<"objc-literal-conversion">;
65 def MacroRedefined : DiagGroup<"macro-redefined">;
66 def BuiltinMacroRedefined : DiagGroup<"builtin-macro-redefined">;
67 def BuiltinRequiresHeader : DiagGroup<"builtin-requires-header">;
68 def C99Compat : DiagGroup<"c99-compat">;
69 def CXXCompat: DiagGroup<"c++-compat">;
70 def ExternCCompat : DiagGroup<"extern-c-compat">;
71 def KeywordCompat : DiagGroup<"keyword-compat">;
72 def GNUCaseRange : DiagGroup<"gnu-case-range">;
73 def CastAlign : DiagGroup<"cast-align">;
74 def CastQual : DiagGroup<"cast-qual">;
75 def : DiagGroup<"char-align">;
76 def Comment : DiagGroup<"comment">;
77 def GNUComplexInteger : DiagGroup<"gnu-complex-integer">;
78 def GNUConditionalOmittedOperand : DiagGroup<"gnu-conditional-omitted-operand">;
79 def ConfigMacros : DiagGroup<"config-macros">;
80 def : DiagGroup<"ctor-dtor-privacy">;
81 def GNUDesignator : DiagGroup<"gnu-designator">;
82 def GNUStringLiteralOperatorTemplate :
83 DiagGroup<"gnu-string-literal-operator-template">;
84 def UndefinedVarTemplate : DiagGroup<"undefined-var-template">;
85 def UndefinedFuncTemplate : DiagGroup<"undefined-func-template">;
87 def DeleteIncomplete : DiagGroup<"delete-incomplete">;
88 def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor">;
89 def AbstractFinalClass : DiagGroup<"abstract-final-class">;
91 def CXX11CompatDeprecatedWritableStr :
92 DiagGroup<"c++11-compat-deprecated-writable-strings">;
94 def DeprecatedAttributes : DiagGroup<"deprecated-attributes">;
95 def DeprecatedDeclarations : DiagGroup<"deprecated-declarations">;
96 def UnavailableDeclarations : DiagGroup<"unavailable-declarations">;
97 def UnguardedAvailability : DiagGroup<"unguarded-availability">;
98 // partial-availability is an alias of unguarded-availability.
99 def : DiagGroup<"partial-availability", [UnguardedAvailability]>;
100 def DeprecatedDynamicExceptionSpec
101 : DiagGroup<"deprecated-dynamic-exception-spec">;
102 def DeprecatedImplementations :DiagGroup<"deprecated-implementations">;
103 def DeprecatedIncrementBool : DiagGroup<"deprecated-increment-bool">;
104 def DeprecatedRegister : DiagGroup<"deprecated-register">;
105 def DeprecatedWritableStr : DiagGroup<"deprecated-writable-strings",
106 [CXX11CompatDeprecatedWritableStr]>;
107 // FIXME: Why is DeprecatedImplementations not in this group?
108 def Deprecated : DiagGroup<"deprecated", [DeprecatedAttributes,
109 DeprecatedDeclarations,
110 DeprecatedDynamicExceptionSpec,
111 DeprecatedIncrementBool,
113 DeprecatedWritableStr]>,
114 DiagCategory<"Deprecations">;
116 def DynamicExceptionSpec
117 : DiagGroup<"dynamic-exception-spec", [DeprecatedDynamicExceptionSpec]>;
119 def LibLTO : DiagGroup<"liblto">;
120 def : DiagGroup<"disabled-optimization">;
121 def : DiagGroup<"discard-qual">;
122 def DivZero : DiagGroup<"division-by-zero">;
123 def : DiagGroup<"div-by-zero", [DivZero]>;
125 def DocumentationHTML : DiagGroup<"documentation-html">;
126 def DocumentationUnknownCommand : DiagGroup<"documentation-unknown-command">;
127 def DocumentationPedantic : DiagGroup<"documentation-pedantic",
128 [DocumentationUnknownCommand]>;
129 def DocumentationDeprecatedSync : DiagGroup<"documentation-deprecated-sync">;
130 def Documentation : DiagGroup<"documentation",
132 DocumentationDeprecatedSync]>;
134 def EmptyBody : DiagGroup<"empty-body">;
135 def Exceptions : DiagGroup<"exceptions">;
137 def GNUEmptyInitializer : DiagGroup<"gnu-empty-initializer">;
138 def GNUEmptyStruct : DiagGroup<"gnu-empty-struct">;
139 def ExtraTokens : DiagGroup<"extra-tokens">;
140 def CXX11ExtraSemi : DiagGroup<"c++11-extra-semi">;
141 def ExtraSemi : DiagGroup<"extra-semi", [CXX11ExtraSemi]>;
143 def GNUFlexibleArrayInitializer : DiagGroup<"gnu-flexible-array-initializer">;
144 def GNUFlexibleArrayUnionMember : DiagGroup<"gnu-flexible-array-union-member">;
145 def GNUFoldingConstant : DiagGroup<"gnu-folding-constant">;
146 def FormatExtraArgs : DiagGroup<"format-extra-args">;
147 def FormatZeroLength : DiagGroup<"format-zero-length">;
149 // Warnings for C++1y code which is not compatible with prior C++ standards.
150 def CXXPre14Compat : DiagGroup<"c++98-c++11-compat">;
151 def CXXPre14CompatPedantic : DiagGroup<"c++98-c++11-compat-pedantic",
153 def CXXPre1zCompat : DiagGroup<"c++98-c++11-c++14-compat">;
154 def CXXPre1zCompatPedantic : DiagGroup<"c++98-c++11-c++14-compat-pedantic",
157 def CXX98CompatBindToTemporaryCopy :
158 DiagGroup<"c++98-compat-bind-to-temporary-copy">;
159 def CXX98CompatLocalTypeTemplateArgs :
160 DiagGroup<"c++98-compat-local-type-template-args">;
161 def CXX98CompatUnnamedTypeTemplateArgs :
162 DiagGroup<"c++98-compat-unnamed-type-template-args">;
164 def CXX98Compat : DiagGroup<"c++98-compat",
165 [CXX98CompatLocalTypeTemplateArgs,
166 CXX98CompatUnnamedTypeTemplateArgs,
169 // Warnings for C++11 features which are Extensions in C++98 mode.
170 def CXX98CompatPedantic : DiagGroup<"c++98-compat-pedantic",
172 CXX98CompatBindToTemporaryCopy,
173 CXXPre14CompatPedantic,
174 CXXPre1zCompatPedantic]>;
176 def CXX11Narrowing : DiagGroup<"c++11-narrowing">;
178 def CXX11WarnOverrideMethod : DiagGroup<"inconsistent-missing-override">;
180 // Original name of this warning in Clang
181 def : DiagGroup<"c++0x-narrowing", [CXX11Narrowing]>;
183 // Name of this warning in GCC
184 def : DiagGroup<"narrowing", [CXX11Narrowing]>;
186 def CXX11CompatReservedUserDefinedLiteral :
187 DiagGroup<"c++11-compat-reserved-user-defined-literal">;
188 def ReservedUserDefinedLiteral :
189 DiagGroup<"reserved-user-defined-literal",
190 [CXX11CompatReservedUserDefinedLiteral]>;
192 def CXX11Compat : DiagGroup<"c++11-compat",
194 CXX11CompatReservedUserDefinedLiteral,
195 CXX11CompatDeprecatedWritableStr,
198 def : DiagGroup<"c++0x-compat", [CXX11Compat]>;
199 def CXX11CompatPedantic : DiagGroup<"c++11-compat-pedantic",
200 [CXXPre14CompatPedantic,
201 CXXPre1zCompatPedantic]>;
203 def CXX14Compat : DiagGroup<"c++14-compat", [CXXPre1zCompat]>;
204 def CXX14CompatPedantic : DiagGroup<"c++14-compat-pedantic",
205 [CXXPre1zCompatPedantic]>;
207 def CXX1zCompat : DiagGroup<"c++1z-compat", [DeprecatedRegister,
208 DeprecatedIncrementBool]>;
210 def ExitTimeDestructors : DiagGroup<"exit-time-destructors">;
211 def FlexibleArrayExtensions : DiagGroup<"flexible-array-extensions">;
212 def FourByteMultiChar : DiagGroup<"four-char-constants">;
213 def GlobalConstructors : DiagGroup<"global-constructors">;
214 def BitwiseOpParentheses: DiagGroup<"bitwise-op-parentheses">;
215 def LogicalOpParentheses: DiagGroup<"logical-op-parentheses">;
216 def LogicalNotParentheses: DiagGroup<"logical-not-parentheses">;
217 def ShiftOpParentheses: DiagGroup<"shift-op-parentheses">;
218 def OverloadedShiftOpParentheses: DiagGroup<"overloaded-shift-op-parentheses">;
219 def DanglingElse: DiagGroup<"dangling-else">;
220 def DanglingField : DiagGroup<"dangling-field">;
221 def DistributedObjectModifiers : DiagGroup<"distributed-object-modifiers">;
222 def ExpansionToDefined : DiagGroup<"expansion-to-defined">;
223 def FlagEnum : DiagGroup<"flag-enum">;
224 def IncrementBool : DiagGroup<"increment-bool", [DeprecatedIncrementBool]>;
225 def InfiniteRecursion : DiagGroup<"infinite-recursion">;
226 def GNUImaginaryConstant : DiagGroup<"gnu-imaginary-constant">;
227 def IgnoredQualifiers : DiagGroup<"ignored-qualifiers">;
228 def : DiagGroup<"import">;
229 def GNUIncludeNext : DiagGroup<"gnu-include-next">;
230 def IncompatibleMSStruct : DiagGroup<"incompatible-ms-struct">;
231 def IncompatiblePointerTypesDiscardsQualifiers
232 : DiagGroup<"incompatible-pointer-types-discards-qualifiers">;
233 def IncompatibleFunctionPointerTypes
234 : DiagGroup<"incompatible-function-pointer-types">;
235 def IncompatiblePointerTypes
236 : DiagGroup<"incompatible-pointer-types",
237 [IncompatiblePointerTypesDiscardsQualifiers,
238 IncompatibleFunctionPointerTypes]>;
239 def IncompleteUmbrella : DiagGroup<"incomplete-umbrella">;
240 def NonModularIncludeInFrameworkModule
241 : DiagGroup<"non-modular-include-in-framework-module">;
242 def NonModularIncludeInModule : DiagGroup<"non-modular-include-in-module",
243 [NonModularIncludeInFrameworkModule]>;
244 def IncompleteModule : DiagGroup<"incomplete-module",
245 [IncompleteUmbrella, NonModularIncludeInModule]>;
246 def PrivateModule : DiagGroup<"private-module">;
248 def CXX11InlineNamespace : DiagGroup<"c++11-inline-namespace">;
249 def InvalidNoreturn : DiagGroup<"invalid-noreturn">;
250 def InvalidSourceEncoding : DiagGroup<"invalid-source-encoding">;
251 def KNRPromotedParameter : DiagGroup<"knr-promoted-parameter">;
252 def : DiagGroup<"init-self">;
253 def : DiagGroup<"inline">;
254 def : DiagGroup<"invalid-pch">;
255 def GNULabelsAsValue : DiagGroup<"gnu-label-as-value">;
256 def LiteralRange : DiagGroup<"literal-range">;
257 def LocalTypeTemplateArgs : DiagGroup<"local-type-template-args",
258 [CXX98CompatLocalTypeTemplateArgs]>;
259 def RangeLoopAnalysis : DiagGroup<"range-loop-analysis">;
260 def ForLoopAnalysis : DiagGroup<"for-loop-analysis">;
261 def LoopAnalysis : DiagGroup<"loop-analysis", [ForLoopAnalysis,
263 def MalformedWarningCheck : DiagGroup<"malformed-warning-check">;
264 def Main : DiagGroup<"main">;
265 def MainReturnType : DiagGroup<"main-return-type">;
266 def MaxUnsignedZero : DiagGroup<"max-unsigned-zero">;
267 def MissingBraces : DiagGroup<"missing-braces">;
268 def MissingDeclarations: DiagGroup<"missing-declarations">;
269 def : DiagGroup<"missing-format-attribute">;
270 def : DiagGroup<"missing-include-dirs">;
271 def MissingNoreturn : DiagGroup<"missing-noreturn">;
272 def MultiChar : DiagGroup<"multichar">;
273 def : DiagGroup<"nested-externs">;
274 def CXX11LongLong : DiagGroup<"c++11-long-long">;
275 def LongLong : DiagGroup<"long-long", [CXX11LongLong]>;
276 def ImplicitlyUnsignedLiteral : DiagGroup<"implicitly-unsigned-literal">;
277 def MethodSignatures : DiagGroup<"method-signatures">;
278 def MismatchedParameterTypes : DiagGroup<"mismatched-parameter-types">;
279 def MismatchedReturnTypes : DiagGroup<"mismatched-return-types">;
280 def MismatchedTags : DiagGroup<"mismatched-tags">;
281 def MissingFieldInitializers : DiagGroup<"missing-field-initializers">;
282 def ModuleBuild : DiagGroup<"module-build">;
283 def ModuleConflict : DiagGroup<"module-conflict">;
284 def ModuleFileExtension : DiagGroup<"module-file-extension">;
285 def NewlineEOF : DiagGroup<"newline-eof">;
286 def Nullability : DiagGroup<"nullability">;
287 def NullabilityDeclSpec : DiagGroup<"nullability-declspec">;
288 def NullabilityInferredOnNestedType : DiagGroup<"nullability-inferred-on-nested-type">;
289 def NullableToNonNullConversion : DiagGroup<"nullable-to-nonnull-conversion">;
290 def NullabilityCompletenessOnArrays : DiagGroup<"nullability-completeness-on-arrays">;
291 def NullabilityCompleteness : DiagGroup<"nullability-completeness",
292 [NullabilityCompletenessOnArrays]>;
293 def NullArithmetic : DiagGroup<"null-arithmetic">;
294 def NullCharacter : DiagGroup<"null-character">;
295 def NullDereference : DiagGroup<"null-dereference">;
296 def InitializerOverrides : DiagGroup<"initializer-overrides">;
297 def NonNull : DiagGroup<"nonnull">;
298 def NonPODVarargs : DiagGroup<"non-pod-varargs">;
299 def ClassVarargs : DiagGroup<"class-varargs", [NonPODVarargs]>;
300 def : DiagGroup<"nonportable-cfstrings">;
301 def NonVirtualDtor : DiagGroup<"non-virtual-dtor">;
302 def : DiagGroup<"effc++", [NonVirtualDtor]>;
303 def OveralignedType : DiagGroup<"over-aligned">;
304 def OldStyleCast : DiagGroup<"old-style-cast">;
305 def : DiagGroup<"old-style-definition">;
306 def OutOfLineDeclaration : DiagGroup<"out-of-line-declaration">;
307 def : DiagGroup<"overflow">;
308 def ForwardClassReceiver : DiagGroup<"receiver-forward-class">;
309 def MethodAccess : DiagGroup<"objc-method-access">;
310 def ObjCReceiver : DiagGroup<"receiver-expr">;
311 def OperatorNewReturnsNull : DiagGroup<"new-returns-null">;
312 def OverlengthStrings : DiagGroup<"overlength-strings">;
313 def OverloadedVirtual : DiagGroup<"overloaded-virtual">;
314 def PrivateExtern : DiagGroup<"private-extern">;
315 def SelTypeCast : DiagGroup<"cast-of-sel-type">;
316 def FunctionDefInObjCContainer : DiagGroup<"function-def-in-objc-container">;
317 def BadFunctionCast : DiagGroup<"bad-function-cast">;
318 def ObjCPropertyImpl : DiagGroup<"objc-property-implementation">;
319 def ObjCPropertyNoAttribute : DiagGroup<"objc-property-no-attribute">;
320 def ObjCProtocolQualifiers : DiagGroup<"objc-protocol-qualifiers">;
321 def ObjCMissingSuperCalls : DiagGroup<"objc-missing-super-calls">;
322 def ObjCDesignatedInit : DiagGroup<"objc-designated-initializers">;
323 def ObjCRetainBlockProperty : DiagGroup<"objc-noncopy-retain-block-property">;
324 def ObjCReadonlyPropertyHasSetter : DiagGroup<"objc-readonly-with-setter-property">;
325 def ObjCInvalidIBOutletProperty : DiagGroup<"invalid-iboutlet">;
326 def ObjCRootClass : DiagGroup<"objc-root-class">;
327 def ObjCPointerIntrospectPerformSelector : DiagGroup<"deprecated-objc-pointer-introspection-performSelector">;
328 def ObjCPointerIntrospect : DiagGroup<"deprecated-objc-pointer-introspection", [ObjCPointerIntrospectPerformSelector]>;
329 def ObjCMultipleMethodNames : DiagGroup<"objc-multiple-method-names">;
330 def OpenCLUnsupportedRGBA: DiagGroup<"opencl-unsupported-rgba">;
331 def DeprecatedObjCIsaUsage : DiagGroup<"deprecated-objc-isa-usage">;
332 def ExplicitInitializeCall : DiagGroup<"explicit-initialize-call">;
333 def Packed : DiagGroup<"packed">;
334 def Padded : DiagGroup<"padded">;
335 def PessimizingMove : DiagGroup<"pessimizing-move">;
336 def PointerArith : DiagGroup<"pointer-arith">;
337 def PoundWarning : DiagGroup<"#warnings">;
338 def PoundPragmaMessage : DiagGroup<"#pragma-messages">,
339 DiagCategory<"#pragma message Directive">;
340 def : DiagGroup<"pointer-to-int-cast">;
341 def : DiagGroup<"redundant-decls">;
342 def RedeclaredClassMember : DiagGroup<"redeclared-class-member">;
343 def GNURedeclaredEnum : DiagGroup<"gnu-redeclared-enum">;
344 def RedundantMove : DiagGroup<"redundant-move">;
345 def Register : DiagGroup<"register", [DeprecatedRegister]>;
346 def ReturnStackAddress : DiagGroup<"return-stack-address">;
347 def ReturnTypeCLinkage : DiagGroup<"return-type-c-linkage">;
348 def ReturnType : DiagGroup<"return-type", [ReturnTypeCLinkage]>;
349 def BindToTemporaryCopy : DiagGroup<"bind-to-temporary-copy",
350 [CXX98CompatBindToTemporaryCopy]>;
351 def SelfAssignmentField : DiagGroup<"self-assign-field">;
352 def SelfAssignment : DiagGroup<"self-assign", [SelfAssignmentField]>;
353 def SelfMove : DiagGroup<"self-move">;
354 def SemiBeforeMethodBody : DiagGroup<"semicolon-before-method-body">;
355 def Sentinel : DiagGroup<"sentinel">;
356 def MissingMethodReturnType : DiagGroup<"missing-method-return-type">;
358 def ShadowFieldInConstructorModified : DiagGroup<"shadow-field-in-constructor-modified">;
359 def ShadowFieldInConstructor : DiagGroup<"shadow-field-in-constructor",
360 [ShadowFieldInConstructorModified]>;
361 def ShadowIvar : DiagGroup<"shadow-ivar">;
362 def ShadowUncapturedLocal : DiagGroup<"shadow-uncaptured-local">;
364 // -Wshadow-all is a catch-all for all shadowing. -Wshadow is just the
365 // shadowing that we think is unsafe.
366 def Shadow : DiagGroup<"shadow", [ShadowFieldInConstructorModified,
368 def ShadowAll : DiagGroup<"shadow-all", [Shadow, ShadowFieldInConstructor,
369 ShadowUncapturedLocal]>;
371 def Shorten64To32 : DiagGroup<"shorten-64-to-32">;
372 def : DiagGroup<"sign-promo">;
373 def SignCompare : DiagGroup<"sign-compare">;
374 def : DiagGroup<"stack-protector">;
375 def : DiagGroup<"switch-default">;
376 def : DiagGroup<"synth">;
377 def SizeofArrayArgument : DiagGroup<"sizeof-array-argument">;
378 def SizeofArrayDecay : DiagGroup<"sizeof-array-decay">;
379 def SizeofPointerMemaccess : DiagGroup<"sizeof-pointer-memaccess">;
380 def StaticInInline : DiagGroup<"static-in-inline">;
381 def StaticLocalInInline : DiagGroup<"static-local-in-inline">;
382 def GNUStaticFloatInit : DiagGroup<"gnu-static-float-init">;
383 def StaticFloatInit : DiagGroup<"static-float-init", [GNUStaticFloatInit]>;
384 def GNUStatementExpression : DiagGroup<"gnu-statement-expression">;
385 def StringCompare : DiagGroup<"string-compare">;
386 def StringPlusInt : DiagGroup<"string-plus-int">;
387 def StringPlusChar : DiagGroup<"string-plus-char">;
388 def StrncatSize : DiagGroup<"strncat-size">;
389 def TautologicalOutOfRangeCompare : DiagGroup<"tautological-constant-out-of-range-compare">;
390 def TautologicalPointerCompare : DiagGroup<"tautological-pointer-compare">;
391 def TautologicalOverlapCompare : DiagGroup<"tautological-overlap-compare">;
392 def TautologicalUndefinedCompare : DiagGroup<"tautological-undefined-compare">;
393 def TautologicalCompare : DiagGroup<"tautological-compare",
394 [TautologicalOutOfRangeCompare,
395 TautologicalPointerCompare,
396 TautologicalOverlapCompare,
397 TautologicalUndefinedCompare]>;
398 def HeaderHygiene : DiagGroup<"header-hygiene">;
399 def DuplicateDeclSpecifier : DiagGroup<"duplicate-decl-specifier">;
400 def CompareDistinctPointerType : DiagGroup<"compare-distinct-pointer-types">;
401 def GNUUnionCast : DiagGroup<"gnu-union-cast">;
402 def GNUVariableSizedTypeNotAtEnd : DiagGroup<"gnu-variable-sized-type-not-at-end">;
403 def Varargs : DiagGroup<"varargs">;
405 def Unsequenced : DiagGroup<"unsequenced">;
406 // GCC name for -Wunsequenced
407 def : DiagGroup<"sequence-point", [Unsequenced]>;
409 // Preprocessor warnings.
410 def AmbiguousMacro : DiagGroup<"ambiguous-macro">;
411 def KeywordAsMacro : DiagGroup<"keyword-macro">;
412 def ReservedIdAsMacro : DiagGroup<"reserved-id-macro">;
414 // Just silence warnings about -Wstrict-aliasing for now.
415 def : DiagGroup<"strict-aliasing=0">;
416 def : DiagGroup<"strict-aliasing=1">;
417 def : DiagGroup<"strict-aliasing=2">;
418 def : DiagGroup<"strict-aliasing">;
420 // Just silence warnings about -Wstrict-overflow for now.
421 def : DiagGroup<"strict-overflow=0">;
422 def : DiagGroup<"strict-overflow=1">;
423 def : DiagGroup<"strict-overflow=2">;
424 def : DiagGroup<"strict-overflow=3">;
425 def : DiagGroup<"strict-overflow=4">;
426 def : DiagGroup<"strict-overflow=5">;
427 def : DiagGroup<"strict-overflow">;
429 def InvalidOffsetof : DiagGroup<"invalid-offsetof">;
430 def : DiagGroup<"strict-prototypes">;
431 def StrictSelector : DiagGroup<"strict-selector-match">;
432 def MethodDuplicate : DiagGroup<"duplicate-method-match">;
433 def ObjCCStringFormat : DiagGroup<"cstring-format-directive">;
434 def CoveredSwitchDefault : DiagGroup<"covered-switch-default">;
435 def SwitchBool : DiagGroup<"switch-bool">;
436 def SwitchEnum : DiagGroup<"switch-enum">;
437 def Switch : DiagGroup<"switch">;
438 def ImplicitFallthroughPerFunction :
439 DiagGroup<"implicit-fallthrough-per-function">;
440 def ImplicitFallthrough : DiagGroup<"implicit-fallthrough",
441 [ImplicitFallthroughPerFunction]>;
442 def InvalidPPToken : DiagGroup<"invalid-pp-token">;
443 def Trigraphs : DiagGroup<"trigraphs">;
445 def : DiagGroup<"type-limits">;
446 def UndefinedReinterpretCast : DiagGroup<"undefined-reinterpret-cast">;
447 def ReinterpretBaseClass : DiagGroup<"reinterpret-base-class">;
448 def Unicode : DiagGroup<"unicode">;
449 def UninitializedMaybe : DiagGroup<"conditional-uninitialized">;
450 def UninitializedSometimes : DiagGroup<"sometimes-uninitialized">;
451 def UninitializedStaticSelfInit : DiagGroup<"static-self-init">;
452 def Uninitialized : DiagGroup<"uninitialized", [UninitializedSometimes,
453 UninitializedStaticSelfInit]>;
454 def IgnoredPragmaIntrinsic : DiagGroup<"ignored-pragma-intrinsic">;
455 def UnknownPragmas : DiagGroup<"unknown-pragmas">;
456 def IgnoredPragmas : DiagGroup<"ignored-pragmas", [IgnoredPragmaIntrinsic]>;
457 def Pragmas : DiagGroup<"pragmas", [UnknownPragmas, IgnoredPragmas]>;
458 def UnknownWarningOption : DiagGroup<"unknown-warning-option">;
459 def NSobjectAttribute : DiagGroup<"NSObject-attribute">;
460 def IndependentClassAttribute : DiagGroup<"IndependentClass-attribute">;
461 def UnknownAttributes : DiagGroup<"unknown-attributes">;
462 def IgnoredAttributes : DiagGroup<"ignored-attributes">;
463 def Attributes : DiagGroup<"attributes", [UnknownAttributes,
465 def UnknownSanitizers : DiagGroup<"unknown-sanitizers">;
466 def UnnamedTypeTemplateArgs : DiagGroup<"unnamed-type-template-args",
467 [CXX98CompatUnnamedTypeTemplateArgs]>;
468 def UnsupportedFriend : DiagGroup<"unsupported-friend">;
469 def UnusedArgument : DiagGroup<"unused-argument">;
470 def UnusedCommandLineArgument : DiagGroup<"unused-command-line-argument">;
471 def IgnoredOptimizationArgument : DiagGroup<"ignored-optimization-argument">;
472 def InvalidCommandLineArgument : DiagGroup<"invalid-command-line-argument",
473 [IgnoredOptimizationArgument]>;
474 def UnusedComparison : DiagGroup<"unused-comparison">;
475 def UnusedExceptionParameter : DiagGroup<"unused-exception-parameter">;
476 def UnneededInternalDecl : DiagGroup<"unneeded-internal-declaration">;
477 def UnneededMemberFunction : DiagGroup<"unneeded-member-function">;
478 def UnusedPrivateField : DiagGroup<"unused-private-field">;
479 def UnusedFunction : DiagGroup<"unused-function", [UnneededInternalDecl]>;
480 def UnusedMemberFunction : DiagGroup<"unused-member-function",
481 [UnneededMemberFunction]>;
482 def UnusedLabel : DiagGroup<"unused-label">;
483 def UnusedParameter : DiagGroup<"unused-parameter">;
484 def UnusedResult : DiagGroup<"unused-result">;
485 def PotentiallyEvaluatedExpression : DiagGroup<"potentially-evaluated-expression">;
486 def UnevaluatedExpression : DiagGroup<"unevaluated-expression",
487 [PotentiallyEvaluatedExpression]>;
488 def UnusedValue : DiagGroup<"unused-value", [UnusedComparison, UnusedResult,
489 UnevaluatedExpression]>;
490 def UnusedConstVariable : DiagGroup<"unused-const-variable">;
491 def UnusedVariable : DiagGroup<"unused-variable",
492 [UnusedConstVariable]>;
493 def UnusedLocalTypedef : DiagGroup<"unused-local-typedef">;
494 def UnusedPropertyIvar : DiagGroup<"unused-property-ivar">;
495 def UnusedGetterReturnValue : DiagGroup<"unused-getter-return-value">;
496 def UsedButMarkedUnused : DiagGroup<"used-but-marked-unused">;
497 def UserDefinedLiterals : DiagGroup<"user-defined-literals">;
498 def UserDefinedWarnings : DiagGroup<"user-defined-warnings">;
499 def Reorder : DiagGroup<"reorder">;
500 def UndeclaredSelector : DiagGroup<"undeclared-selector">;
501 def ImplicitAtomic : DiagGroup<"implicit-atomic-properties">;
502 def CustomAtomic : DiagGroup<"custom-atomic-properties">;
503 def AtomicProperties : DiagGroup<"atomic-properties",
504 [ImplicitAtomic, CustomAtomic]>;
505 def ARCUnsafeRetainedAssign : DiagGroup<"arc-unsafe-retained-assign">;
506 def ARCRetainCycles : DiagGroup<"arc-retain-cycles">;
507 def ARCNonPodMemAccess : DiagGroup<"arc-non-pod-memaccess">;
508 def AutomaticReferenceCounting : DiagGroup<"arc",
509 [ARCUnsafeRetainedAssign,
511 ARCNonPodMemAccess]>;
512 def ARCRepeatedUseOfWeakMaybe : DiagGroup<"arc-maybe-repeated-use-of-weak">;
513 def ARCRepeatedUseOfWeak : DiagGroup<"arc-repeated-use-of-weak",
514 [ARCRepeatedUseOfWeakMaybe]>;
515 def BlockCaptureAutoReleasing : DiagGroup<"block-capture-autoreleasing">;
516 def ObjCBridge : DiagGroup<"bridge-cast">;
518 def DeallocInCategory:DiagGroup<"dealloc-in-category">;
519 def SelectorTypeMismatch : DiagGroup<"selector-type-mismatch">;
520 def Selector : DiagGroup<"selector", [SelectorTypeMismatch]>;
521 def Protocol : DiagGroup<"protocol">;
522 def AtProtocol : DiagGroup<"at-protocol">;
523 def PropertyAccessDotSyntax: DiagGroup<"property-access-dot-syntax">;
524 def PropertyAttr : DiagGroup<"property-attribute-mismatch">;
525 def SuperSubClassMismatch : DiagGroup<"super-class-method-mismatch">;
526 def OverridingMethodMismatch : DiagGroup<"overriding-method-mismatch">;
527 def VariadicMacros : DiagGroup<"variadic-macros">;
528 def VectorConversion : DiagGroup<"vector-conversion">; // clang specific
529 def VexingParse : DiagGroup<"vexing-parse">;
530 def VLA : DiagGroup<"vla">;
531 def VLAExtension : DiagGroup<"vla-extension">;
532 def VolatileRegisterVar : DiagGroup<"volatile-register-var">;
533 def Visibility : DiagGroup<"visibility">;
534 def ZeroLengthArray : DiagGroup<"zero-length-array">;
535 def GNUZeroLineDirective : DiagGroup<"gnu-zero-line-directive">;
536 def GNUZeroVariadicMacroArguments : DiagGroup<"gnu-zero-variadic-macro-arguments">;
537 def Fallback : DiagGroup<"fallback">;
539 // This covers both the deprecated case (in C++98)
540 // and the extension case (in C++11 onwards).
541 def WritableStrings : DiagGroup<"writable-strings", [DeprecatedWritableStr]>;
543 // GCC calls -Wdeprecated-writable-strings -Wwrite-strings.
545 // Bizarrely, this warning flag enables -fconst-strings in C. This is
546 // GCC-compatible, but really weird.
548 // FIXME: Should this affect C++11 (where this is an error,
549 // not just deprecated) or not?
550 def GCCWriteStrings : DiagGroup<"write-strings" , [WritableStrings]>;
552 def CharSubscript : DiagGroup<"char-subscripts">;
553 def LargeByValueCopy : DiagGroup<"large-by-value-copy">;
554 def DuplicateArgDecl : DiagGroup<"duplicate-method-arg">;
555 def SignedEnumBitfield : DiagGroup<"signed-enum-bitfield">;
557 // Unreachable code warning groups.
559 // The goal is make -Wunreachable-code on by default, in -Wall, or at
560 // least actively used, with more noisy versions of the warning covered
561 // under separate flags.
563 def UnreachableCodeLoopIncrement : DiagGroup<"unreachable-code-loop-increment">;
564 def UnreachableCode : DiagGroup<"unreachable-code",
565 [UnreachableCodeLoopIncrement]>;
566 def UnreachableCodeBreak : DiagGroup<"unreachable-code-break">;
567 def UnreachableCodeReturn : DiagGroup<"unreachable-code-return">;
568 def UnreachableCodeAggressive : DiagGroup<"unreachable-code-aggressive",
570 UnreachableCodeBreak,
571 UnreachableCodeReturn]>;
573 // Aggregation warning settings.
575 // Populate -Waddress with warnings from other groups.
576 def : DiagGroup<"address", [PointerBoolConversion,
578 TautologicalPointerCompare]>;
580 // -Widiomatic-parentheses contains warnings about 'idiomatic'
581 // missing parentheses; it is off by default. We do not include it
582 // in -Wparentheses because most users who use -Wparentheses explicitly
583 // do not want these warnings.
584 def ParenthesesOnEquality : DiagGroup<"parentheses-equality">;
585 def Parentheses : DiagGroup<"parentheses",
586 [LogicalOpParentheses,
587 LogicalNotParentheses,
588 BitwiseOpParentheses,
590 OverloadedShiftOpParentheses,
591 ParenthesesOnEquality,
594 // -Wconversion has its own warnings, but we split a few out for
596 // - some people want just 64-to-32 warnings
597 // - conversion warnings with constant sources are on by default
598 // - conversion warnings for literals are on by default
599 // - bool-to-pointer conversion warnings are on by default
600 // - __null-to-integer conversion warnings are on by default
601 def Conversion : DiagGroup<"conversion",
609 NonLiteralNullConversion, // (1-1)->pointer (etc)
610 NullConversion, // NULL->non-pointer
611 ObjCLiteralConversion,
614 DiagCategory<"Value Conversion Issue">;
616 def Unused : DiagGroup<"unused",
617 [UnusedArgument, UnusedFunction, UnusedLabel,
618 // UnusedParameter, (matches GCC's behavior)
619 // UnusedMemberFunction, (clean-up llvm before enabling)
620 UnusedPrivateField, UnusedLocalTypedef,
621 UnusedValue, UnusedVariable, UnusedPropertyIvar]>,
622 DiagCategory<"Unused Entity Issue">;
625 def FormatInvalidSpecifier : DiagGroup<"format-invalid-specifier">;
626 def FormatSecurity : DiagGroup<"format-security">;
627 def FormatNonStandard : DiagGroup<"format-non-iso">;
628 def FormatY2K : DiagGroup<"format-y2k">;
629 def FormatPedantic : DiagGroup<"format-pedantic">;
630 def Format : DiagGroup<"format",
631 [FormatExtraArgs, FormatZeroLength, NonNull,
632 FormatSecurity, FormatY2K, FormatInvalidSpecifier]>,
633 DiagCategory<"Format String Issue">;
634 def FormatNonLiteral : DiagGroup<"format-nonliteral">;
635 def Format2 : DiagGroup<"format=2",
636 [FormatNonLiteral, FormatSecurity, FormatY2K]>;
638 def TypeSafety : DiagGroup<"type-safety">;
640 def IncompatibleExceptionSpec : DiagGroup<"incompatible-exception-spec">;
642 def IntToVoidPointerCast : DiagGroup<"int-to-void-pointer-cast">;
643 def IntToPointerCast : DiagGroup<"int-to-pointer-cast",
644 [IntToVoidPointerCast]>;
646 def Move : DiagGroup<"move", [PessimizingMove, RedundantMove, SelfMove]>;
648 def Extra : DiagGroup<"extra", [
649 MissingFieldInitializers,
651 InitializerOverrides,
652 SemiBeforeMethodBody,
653 MissingMethodReturnType,
658 def Most : DiagGroup<"most", [
661 DeleteNonVirtualDtor,
682 ObjCMissingSuperCalls,
691 // Thread Safety warnings
692 def ThreadSafetyAttributes : DiagGroup<"thread-safety-attributes">;
693 def ThreadSafetyAnalysis : DiagGroup<"thread-safety-analysis">;
694 def ThreadSafetyPrecise : DiagGroup<"thread-safety-precise">;
695 def ThreadSafetyReference : DiagGroup<"thread-safety-reference">;
696 def ThreadSafetyNegative : DiagGroup<"thread-safety-negative">;
697 def ThreadSafety : DiagGroup<"thread-safety",
698 [ThreadSafetyAttributes,
699 ThreadSafetyAnalysis,
701 ThreadSafetyReference]>;
702 def ThreadSafetyVerbose : DiagGroup<"thread-safety-verbose">;
703 def ThreadSafetyBeta : DiagGroup<"thread-safety-beta">;
705 // Uniqueness Analysis warnings
706 def Consumed : DiagGroup<"consumed">;
708 // Note that putting warnings in -Wall will not disable them by default. If a
709 // warning should be active _only_ when -Wall is passed in, mark it as
710 // DefaultIgnore in addition to putting it here.
711 def All : DiagGroup<"all", [Most, Parentheses, Switch, SwitchBool]>;
713 // Warnings that should be in clang-cl /w4.
714 def : DiagGroup<"CL4", [All, Extra]>;
716 // Warnings enabled by -pedantic. This is magically filled in by TableGen.
717 def Pedantic : DiagGroup<"pedantic">;
720 def : DiagGroup<"", [Extra]>; // -W = -Wextra
721 def : DiagGroup<"endif-labels", [ExtraTokens]>; // -Wendif-labels=-Wextra-tokens
722 def : DiagGroup<"comments", [Comment]>; // -Wcomments = -Wcomment
723 def : DiagGroup<"conversion-null",
724 [NullConversion]>; // -Wconversion-null = -Wnull-conversion
725 def : DiagGroup<"bool-conversions",
726 [BoolConversion]>; // -Wbool-conversions = -Wbool-conversion
727 def : DiagGroup<"int-conversions",
728 [IntConversion]>; // -Wint-conversions = -Wint-conversion
729 def : DiagGroup<"vector-conversions",
730 [VectorConversion]>; // -Wvector-conversions = -Wvector-conversion
731 def : DiagGroup<"unused-local-typedefs", [UnusedLocalTypedef]>;
732 // -Wunused-local-typedefs = -Wunused-local-typedef
734 // A warning group for warnings that we want to have on by default in clang,
735 // but which aren't on by default in GCC.
736 def NonGCC : DiagGroup<"non-gcc",
737 [SignCompare, Conversion, LiteralRange]>;
739 // A warning group for warnings about using C++11 features as extensions in
740 // earlier C++ versions.
741 def CXX11 : DiagGroup<"c++11-extensions", [CXX11ExtraSemi, CXX11InlineNamespace,
744 // A warning group for warnings about using C++14 features as extensions in
745 // earlier C++ versions.
746 def CXX14 : DiagGroup<"c++14-extensions", [CXX14BinaryLiteral]>;
748 // A warning group for warnings about using C++1z features as extensions in
749 // earlier C++ versions.
750 def CXX1z : DiagGroup<"c++1z-extensions">;
752 def : DiagGroup<"c++0x-extensions", [CXX11]>;
753 def : DiagGroup<"c++1y-extensions", [CXX14]>;
755 def DelegatingCtorCycles :
756 DiagGroup<"delegating-ctor-cycles">;
758 // A warning group for warnings about using C11 features as extensions.
759 def C11 : DiagGroup<"c11-extensions">;
761 // A warning group for warnings about using C99 features as extensions.
762 def C99 : DiagGroup<"c99-extensions">;
764 // A warning group for warnings about GCC extensions.
765 def GNU : DiagGroup<"gnu", [GNUAlignofExpression, GNUAnonymousStruct,
767 GNUBinaryLiteral, GNUCaseRange,
768 GNUComplexInteger, GNUCompoundLiteralInitializer,
769 GNUConditionalOmittedOperand, GNUDesignator,
770 GNUEmptyInitializer, GNUEmptyStruct,
771 VLAExtension, GNUFlexibleArrayInitializer,
772 GNUFlexibleArrayUnionMember, GNUFoldingConstant,
773 GNUImaginaryConstant, GNUIncludeNext,
775 RedeclaredClassMember, GNURedeclaredEnum,
776 GNUStatementExpression, GNUStaticFloatInit,
777 GNUStringLiteralOperatorTemplate,
778 GNUUnionCast, GNUVariableSizedTypeNotAtEnd,
779 ZeroLengthArray, GNUZeroLineDirective,
780 GNUZeroVariadicMacroArguments]>;
781 // A warning group for warnings about code that clang accepts but gcc doesn't.
782 def GccCompat : DiagGroup<"gcc-compat">;
784 // Warnings for Microsoft extensions.
785 def MicrosoftCharize : DiagGroup<"microsoft-charize">;
786 def MicrosoftInclude : DiagGroup<"microsoft-include">;
787 def MicrosoftCppMacro : DiagGroup<"microsoft-cpp-macro">;
788 def MicrosoftFixedEnum : DiagGroup<"microsoft-fixed-enum">;
789 def MicrosoftSealed : DiagGroup<"microsoft-sealed">;
790 def MicrosoftUnqualifiedFriend : DiagGroup<"microsoft-unqualified-friend">;
791 def MicrosoftExceptionSpec : DiagGroup<"microsoft-exception-spec">;
792 def MicrosoftUsingDecl : DiagGroup<"microsoft-using-decl">;
793 def MicrosoftMutableReference : DiagGroup<"microsoft-mutable-reference">;
794 def MicrosoftPureDefinition : DiagGroup<"microsoft-pure-definition">;
795 def MicrosoftUnionMemberReference : DiagGroup<
796 "microsoft-union-member-reference">;
797 def MicrosoftExplicitConstructorCall : DiagGroup<
798 "microsoft-explicit-constructor-call">;
799 def MicrosoftEnumValue : DiagGroup<"microsoft-enum-value">;
800 def MicrosoftDefaultArgRedefinition :
801 DiagGroup<"microsoft-default-arg-redefinition">;
802 def MicrosoftTemplate : DiagGroup<"microsoft-template">;
803 def MicrosoftInconsistentDllImport : DiagGroup<"inconsistent-dllimport">;
804 def MicrosoftRedeclareStatic : DiagGroup<"microsoft-redeclare-static">;
805 def MicrosoftEnumForwardReference :
806 DiagGroup<"microsoft-enum-forward-reference">;
807 def MicrosoftGoto : DiagGroup<"microsoft-goto">;
808 def MicrosoftFlexibleArray : DiagGroup<"microsoft-flexible-array">;
809 def MicrosoftExtraQualification : DiagGroup<"microsoft-extra-qualification">;
810 def MicrosoftCast : DiagGroup<"microsoft-cast">;
811 def MicrosoftConstInit : DiagGroup<"microsoft-const-init">;
812 def MicrosoftVoidPseudoDtor : DiagGroup<"microsoft-void-pseudo-dtor">;
813 def MicrosoftAnonTag : DiagGroup<"microsoft-anon-tag">;
814 def MicrosoftCommentPaste : DiagGroup<"microsoft-comment-paste">;
815 def MicrosoftEndOfFile : DiagGroup<"microsoft-end-of-file">;
817 def : DiagGroup<"msvc-include", [MicrosoftInclude]>;
818 // -Wmsvc-include = -Wmicrosoft-include
820 // Warnings group for warnings about Microsoft extensions.
821 def Microsoft : DiagGroup<"microsoft",
822 [MicrosoftCharize, MicrosoftInclude, MicrosoftCppMacro, MicrosoftFixedEnum,
823 MicrosoftSealed, MicrosoftUnqualifiedFriend, MicrosoftExceptionSpec,
824 MicrosoftUsingDecl, MicrosoftMutableReference, MicrosoftPureDefinition,
825 MicrosoftUnionMemberReference, MicrosoftExplicitConstructorCall,
826 MicrosoftEnumValue, MicrosoftDefaultArgRedefinition, MicrosoftTemplate,
827 MicrosoftRedeclareStatic, MicrosoftEnumForwardReference, MicrosoftGoto,
828 MicrosoftFlexibleArray, MicrosoftExtraQualification, MicrosoftCast,
829 MicrosoftConstInit, MicrosoftVoidPseudoDtor, MicrosoftAnonTag,
830 MicrosoftCommentPaste, MicrosoftEndOfFile,
831 MicrosoftInconsistentDllImport]>;
833 def ClangClPch : DiagGroup<"clang-cl-pch">;
835 def ObjCNonUnifiedException : DiagGroup<"objc-nonunified-exceptions">;
837 def ObjCProtocolMethodImpl : DiagGroup<"objc-protocol-method-implementation">;
839 def ObjCNoPropertyAutoSynthesis : DiagGroup<"objc-property-synthesis">;
841 // ObjC API warning groups.
842 def ObjCRedundantLiteralUse : DiagGroup<"objc-redundant-literal-use">;
843 def ObjCRedundantAPIUse : DiagGroup<"objc-redundant-api-use", [
844 ObjCRedundantLiteralUse
847 def ObjCCocoaAPI : DiagGroup<"objc-cocoa-api", [
851 def ObjCStringComparison : DiagGroup<"objc-string-compare">;
852 def ObjCStringConcatenation : DiagGroup<"objc-string-concatenation">;
853 def ObjCLiteralComparison : DiagGroup<"objc-literal-compare", [
857 // Inline ASM warnings.
858 def ASMOperandWidths : DiagGroup<"asm-operand-widths">;
859 def ASMIgnoredQualifier : DiagGroup<"asm-ignored-qualifier">;
860 def ASM : DiagGroup<"asm", [
861 ASMOperandWidths, ASMIgnoredQualifier
865 def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">;
866 def OpenMPClauses : DiagGroup<"openmp-clauses">;
867 def OpenMPLoopForm : DiagGroup<"openmp-loop-form">;
868 def OpenMPTarget : DiagGroup<"openmp-target">;
871 def BackendInlineAsm : DiagGroup<"inline-asm">;
872 def BackendFrameLargerThanEQ : DiagGroup<"frame-larger-than=">;
873 def BackendPlugin : DiagGroup<"backend-plugin">;
874 def RemarkBackendPlugin : DiagGroup<"remark-backend-plugin">;
875 def BackendOptimizationRemark : DiagGroup<"pass">;
876 def BackendOptimizationRemarkMissed : DiagGroup<"pass-missed">;
877 def BackendOptimizationRemarkAnalysis : DiagGroup<"pass-analysis">;
878 def BackendOptimizationFailure : DiagGroup<"pass-failed">;
880 // Instrumentation based profiling warnings.
881 def ProfileInstrOutOfDate : DiagGroup<"profile-instr-out-of-date">;
882 def ProfileInstrUnprofiled : DiagGroup<"profile-instr-unprofiled">;
884 // AddressSanitizer frontent instrumentation remarks.
885 def SanitizeAddressRemarks : DiagGroup<"sanitize-address">;
887 // Issues with serialized diagnostics.
888 def SerializedDiagnostics : DiagGroup<"serialized-diagnostics">;
890 // A warning group for warnings about code that clang accepts when
891 // compiling CUDA C/C++ but which is not compatible with the CUDA spec.
892 def CudaCompat : DiagGroup<"cuda-compat">;
894 // A warning group for things that will change semantics in the future.
895 def FutureCompat : DiagGroup<"future-compat">;
897 def InvalidOrNonExistentDirectory : DiagGroup<"invalid-or-nonexistent-directory">;
899 def OptionIgnored : DiagGroup<"option-ignored">;
901 def UnknownArgument : DiagGroup<"unknown-argument">;
903 // A warning group for warnings about code that clang accepts when
904 // compiling OpenCL C/C++ but which is not compatible with the SPIR spec.
905 def SpirCompat : DiagGroup<"spir-compat">;