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