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